狂盗一枝梅的博客

解决Windows命令行cmd中文乱码问题

Wed, 08 Apr 2026 18:46:12 +0800

一、乱码现象

最近使用DataX迁移数据的时候命令行中文输出乱码了，如下所示：

这是因为DataX程序是使用UTF-8编码开发、打包的，而Windows命令行默认使用的不是UTF-8编码，

命令行属性中可以看到，默认使用的是GBK编码，所以产生了中文乱码。

二、临时解决方案

在命令行中直接执行命令

chcp 65001

执行完成之后就可以发现控制台编码已经变成了UTF-8

常见代码页对照表

代码页	对应编码	适用场景
936	GBK	简体中文系统默认，兼容性最佳
65001	UTF-8	跨平台开发、国际通用字符
437	ASCII	美国英语（原始DOS默认）
950	Big5	繁体中文（台湾、香港）

三、永久解决方案

修改注册表：快捷键Win+R，键入regedit，找到注册表HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor，并找到AutoRun选项，如果没有，则新建一个。

修改值为chcp 65001

这样，每次打开新的控制台窗口，就会自动设置编码为UTF-8了。

转载自：https://cloud.tencent.com/developer/article/2084809

记一次Mybatis查询中的数组越界异常

Thu, 02 Apr 2026 15:01:51 +0800

最近遇到了一件极其诡异的Mybatis查询数组越界异常（java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException）的问题，排查了一天，最终解决了该问题。

一、问题描述

Mapper代码

@Mapper
public interface ISmeBidDailyMapper extends BaseMapper<SmeBidDaily> {

    List<SmeBidDaily> listQuery(@Param("lastMaxId") Long lastMaxId,
                                @Param("maxDataTime") String maxDataTime,
                                @Param("pageSize") Integer pageSize);

}

对应的XMl代码

    <select id="listQuery" resultType="com.cosmoplat.gfqd.gxh.data.syn.bid.sme_bid_daily.entity.SmeBidDaily">
        SELECT
          *
        FROM `sme_bid_daily`
        WHERE id &gt; #{lastMaxId}
        AND `created_at` &lt;= #{maxDataTime}
        ORDER BY id ASC
        limit #{pageSize}
    </select>

以上代码运行的时候，会抛出两种错误：

第一种错误：

JDBC Connection [HikariProxyConnection@1915066553 wrapping com.mysql.cj.jdbc.ConnectionImpl@2c9a855f] will not be managed by Spring
==> Preparing: SELECT id, mid, attachment_flag, bid_type, bid_info_type, bid_project_title, bid_num, bid_location, bid_province, bid_project_category, budgetary, bid_ent, proxy_ent, bid_win, contact, contact_type, contact_person, contact_has_more, bid_pubtime, updated, region_code, title_key_word, text_key_word, product_word, ent_nic, match_text, bid_text, state, created_at, original_url FROM `sme_bid_daily` WHERE id > ? AND `created_at` <= ? ORDER BY id ASC limit ?
==> Parameters: 1604549(Long), 2026-04-30T00:00(LocalDateTime), 10000(Integer)
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@49af67c7]
2026-04-01 15:23:37 [Thread-22] ERROR c.c.g.g.d.s.b.s.j.SynSmeBidDailyToEs -
org.springframework.dao.TransientDataAccessResourceException:
### Error querying database. Cause: java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException: 31
### The error may exist in class path resource [mappers/ISmeBidDailyMapper.xml]
### The error may involve defaultParameterMap
### The error occurred while setting parameters
### SQL: SELECT id, mid, attachment_flag, bid_type, bid_info_type, bid_project_title, bid_num, bid_location, bid_province, bid_project_category, budgetary, bid_ent, proxy_ent, bid_win, contact, contact_type, contact_person, contact_has_more, bid_pubtime, updated, region_code, title_key_word, text_key_word, product_word, ent_nic, match_text, bid_text, state, created_at, original_url FROM `sme_bid_daily` WHERE id > ? AND `created_at` <= ? ORDER BY id ASC limit ?
### Cause: java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException: 31
; java.lang.ArrayIndexOutOfBoundsException: 31; nested exception is java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException: 31

第二种错误：

2026-04-01 15:23:43 [Thread-22] ERROR c.c.g.g.d.s.b.s.j.SynSmeBidDailyToEs -
org.springframework.dao.TransientDataAccessResourceException:
### Error querying database. Cause: java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException
### The error may exist in class path resource [mappers/ISmeBidDailyMapper.xml]
### The error may involve defaultParameterMap
### The error occurred while setting parameters
### SQL: SELECT id, mid, attachment_flag, bid_type, bid_info_type, bid_project_title, bid_num, bid_location, bid_province, bid_project_category, budgetary, bid_ent, proxy_ent, bid_win, contact, contact_type, contact_person, contact_has_more, bid_pubtime, updated, region_code, title_key_word, text_key_word, product_word, ent_nic, match_text, bid_text, state, created_at, original_url FROM `sme_bid_daily` WHERE id > ? AND `created_at` <= ? ORDER BY id ASC limit ?
### Cause: java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException
; java.lang.ArrayIndexOutOfBoundsException; nested exception is java.sql.SQLException: java.lang.ArrayIndexOutOfBoundsException
    ......
Caused by: java.lang.ArrayIndexOutOfBoundsException: null

二、规律总结

一开始怀疑本地的jdk和k3s集群运行的jre版本不同，我本地的jdk是oracle jdk，在k3s集群容器环境下运行的是openjdk-internel版本，我将k3s集群容器中的jre和我本地的jdk统统都换成了jdk8u482-b08版本，但是问题依旧，所以排除了和运行的jdk版本的关系；

又怀疑jenkins打包是否发生了什么问题，所以我将容器中的jar包取出来在本地运行，结果本地运行一点问题没有，无法复现；

至此，我本地的jdk和jar包都和线上保持一致了，but我本地运行N次还是没有复现问题，线上请求一两次就会报错，甚至连续请求连续报错。

我都开始怀疑人生了，干了这么多年的后端开发，第一次遇到这种诡异的问题。

后来怀疑是不是k3s集群的问题，我将同样的镜像部署到k8s集群中运行，结果k8s集群中运行是好的，没法复现，这说明是k3s集群有问题？

怀疑k3s网络有问题，听说MTU设置的不对也会出现这个问题，但是为什么别的服务没有问题，就单单这个服务出了问题？接着又怀疑jdbc链接中设置的不对，禁止了Mysql服务端预编译，仍然没有解决问题。

经过反复测试，最终发现了如下规律：

1、在本地环境下无法复现

2、在k3s集群中稳定复现，通常调用两三次就能出现上述异常

3、在k8s集群中无法复现

4、在linux环境非容器环境无法复现

5、和Mysql的JDBC服务端预编译配置无关

通过保持单一变量原则的测试，唯一有可能存在问题的是k3s的运行环境有问题，否则说不通为什么相同的镜像在k8s集群中运行没有问题。

最后没法子了，只能远程debug，远程debug也行不通，因为这个问题时好时坏，不能每次都重现，找到了抛出异常的地方，但是真正执行逻辑的方法已经在方法栈中弹出，堆栈信息已经没有了，断点都不知道打在什么地方。

问题陷入了死循环，似乎根本无解，至此我唯一能想到的解决方案就是不再在容器中运行，把jar包拿出来直接放到宿主机使用java -jar 启动。

三、解决问题

要不说还得是大模型，大模型随口提了一句检查下mysql驱动是否有问题，最后实在没招的我，把mysql驱动从

<dependency>
    <artifactId>mysql-connector-java</artifactId>
    <groupId>mysql</groupId>
    <version>8.0.31</version>
</dependency>

替换成了

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.33</version>
</dependency>

问题竟然解决了。。。问题解决了，解决了问题的我内心没有丝毫波澜，只有满肚子的疑问。

1、如果是驱动的问题，为什么在本地无法复现问题，在k8s集群中没有复现问题，只有在k3s集群中出现了数组越界异常的问题。

2、为什么在k3s集群中有时候有问题，有时候没问题，这个还能有偶发性情况吗。

END.

IDEA远程Debug

Thu, 02 Apr 2026 14:00:13 +0800

线上出了问题，但是本地不能重现，可以通过IDEA远程Debug功能远程调试排查问题。具体操作如下：

一、本地IDEA配置

单击项目顶部“Edit Configurations”

新增运行配置："Remote JVM Debug"

之后进入远程Debug配置页面：

页面上有些配置，配置详情如下所示：

1、Debugger mode

有两种模式：

Attach to remote JVM：最常使用的模式，本地连接远程JVM，需要确保远程端口号（默认5005,可自定义）开放能够被本地连接

Listen to remote JVM：不常使用的模式，远端连接本地JVM，需要确保本地端口号（默认5005,可自定义）开放能够被远端连接

2、Transport

调试和被调试的JVM的通信方式。

Socket：套接字连接的方式，通过TCP方式通信，适用于调试的JVM和被调试的JVM在不同机器上的情况。

Shared memory：共享内存方式，适用于调试的JVM和被调试的JVM在相同的机器上的情况，传输速度比Socket快。

3、JDK选择

根据运行的JVM情况，选择对应的JDK版本，不同的JDK版本对应不同的运行命令

将命令行参数复制到被调试JVM的启动命令行中。

4、use module classpath选择

如果是maven组织的多模块项目，选择根模块即可。

二、远程JVM配置

根据上一步复制的命令行参数，比如Java8，需要将命令行参数

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

复制到启动命令行，比如完整的jar包启动命令：

java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -jar app.jar

三、调试

先启动远程jar包，jar包启动命令行第一行输出会提示"Listening for transport dt_socket at address: 5005"，这表示自己已经准备好客户端远程调试了。

之后点击IDEA的调试启动按钮

如果连接成功，则会在输出控制台输出类似如下内容：

Connected to the target VM, address: '10.182.50.44:31819', transport: 'socket'

之后正常打断点，远程JVM运行到断点处代码，本地IDEA会自动跳转到对应的断点处代码。

END。

Python脚本：查询占用端口号进程

Tue, 31 Mar 2026 17:12:42 +0800

作为后端开发，端口号被占用是经常遇到的事情，但是为了查询该问题却并不容易，下面使用一个脚本解决该问题，首先需要安装依赖：pip install psutil

完整的脚本如下所示：

import subprocess
import re
import psutil
import argparse
from typing import Optional, Dict, List


def get_process_by_port(port: int) -> Optional[Dict]:
    """
    通过端口号获取进程信息
    """
    try:
        # 使用netstat命令查找占用端口的进程
        cmd = f"netstat -ano | findstr :{port}"
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

        if result.returncode != 0:
            return None

        output_lines = result.stdout.strip().split('\n')
        processes = []

        for line in output_lines:
            if not line.strip():
                continue

            # 解析netstat输出
            parts = re.split(r'\s+', line.strip())

            if len(parts) >= 5:
                protocol = parts[0]
                local_address = parts[1]
                pid = parts[-1]  # 最后一个是PID

                # 验证端口匹配
                if f":{port}" in local_address:
                    try:
                        pid_int = int(pid)
                        process = psutil.Process(pid_int)

                        process_info = {
                            'pid': pid_int,
                            'name': process.name(),
                            'exe': process.exe(),
                            'status': process.status(),
                            'create_time': process.create_time(),
                            'cmdline': ' '.join(process.cmdline()),
                            'username': process.username(),
                            'protocol': protocol,
                            'local_address': local_address
                        }
                        processes.append(process_info)

                    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                        # 进程可能已结束或无权限访问
                        continue

        return processes if processes else None

    except Exception as e:
        print(f"错误: {e}")
        return None


def get_all_processes() -> List[Dict]:
    """
    获取所有进程的基本信息
    """
    processes = []
    for proc in psutil.process_iter(['pid', 'name', 'exe']):
        try:
            process_info = proc.info
            processes.append(process_info)
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    return processes


def search_process_by_keyword(keyword: str) -> List[Dict]:
    """
    通过关键字搜索进程
    """
    matched = []
    for proc in psutil.process_iter(['pid', 'name', 'exe', 'cmdline']):
        try:
            info = proc.info
            # 在进程名、可执行文件路径和命令行中搜索
            if (keyword.lower() in info['name'].lower() or
                    (info['exe'] and keyword.lower() in info['exe'].lower()) or
                    (info['cmdline'] and any(keyword.lower() in str(arg).lower()
                                             for arg in info['cmdline']))):
                matched.append(info)
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    return matched


def display_process_info(processes: List[Dict], show_details: bool = False):
    """
    显示进程信息
    """
    if not processes:
        print("未找到相关进程")
        return

    print(f"\n找到 {len(processes)} 个进程:")
    print("=" * 80)

    for i, proc in enumerate(processes, 1):
        print(f"\n[{i}] PID: {proc.get('pid')}")
        print(f"    进程名: {proc.get('name', 'N/A')}")
        print(f"    可执行文件: {proc.get('exe', 'N/A')}")

        if 'protocol' in proc:
            print(f"    协议: {proc.get('protocol')}")
            print(f"    本地地址: {proc.get('local_address')}")

        if show_details:
            print(f"    状态: {proc.get('status', 'N/A')}")
            print(f"    用户名: {proc.get('username', 'N/A')}")
            print(f"    命令行: {proc.get('cmdline', 'N/A')}")
            if 'create_time' in proc:
                from datetime import datetime
                create_time = datetime.fromtimestamp(proc['create_time'])
                print(f"    创建时间: {create_time.strftime('%Y-%m-%d %H:%M:%S')}")

    print("=" * 80)


def main():
    parser = argparse.ArgumentParser(description='Windows端口进程查询工具')
    parser.add_argument('-p', '--port', type=int, help='指定端口号')
    parser.add_argument('-s', '--search', help='搜索进程名或路径中的关键字')
    parser.add_argument('-l', '--list', action='store_true', help='列出所有进程')
    parser.add_argument('-d', '--details', action='store_true', help='显示详细信息')
    parser.add_argument('-k', '--kill', type=int, nargs='+', help='终止指定PID的进程')

    args = parser.parse_args()

    if args.port:
        # 查询指定端口
        processes = get_process_by_port(args.port)
        if processes:
            display_process_info(processes, args.details)
        else:
            print(f"端口 {args.port} 未被任何进程占用")

    elif args.search:
        # 搜索进程
        processes = search_process_by_keyword(args.search)
        display_process_info(processes, args.details)

    elif args.list:
        # 列出所有进程
        processes = get_all_processes()
        print(f"系统中共有 {len(processes)} 个进程:")
        display_process_info(processes[:50], args.details)  # 默认显示前50个
        if len(processes) > 50:
            print(f"\n(只显示前50个进程，使用搜索功能查看特定进程)")

    elif args.kill:
        # 终止进程
        for pid in args.kill:
            try:
                process = psutil.Process(pid)
                process_name = process.name()
                process.terminate()  # 尝试正常终止
                print(f"已发送终止信号给进程 {pid} ({process_name})")

                # 等待进程结束
                try:
                    process.wait(timeout=3)
                    print(f"进程 {pid} 已成功终止")
                except psutil.TimeoutExpired:
                    process.kill()  # 强制终止
                    print(f"进程 {pid} 被强制终止")

            except psutil.NoSuchProcess:
                print(f"进程 {pid} 不存在")
            except psutil.AccessDenied:
                print(f"无权限终止进程 {pid}")
            except Exception as e:
                print(f"终止进程 {pid} 时出错: {e}")

    else:
        # 交互模式
        while True:
            print("\n" + "=" * 50)
            print("Windows 端口进程查询工具")
            print("=" * 50)
            print("1. 查询端口占用")
            print("2. 搜索进程")
            print("3. 列出所有进程")
            print("4. 终止进程")
            print("0. 退出")

            try:
                choice = input("\n请选择操作 (0-4): ").strip()

                if choice == '1':
                    port = input("请输入端口号: ").strip()
                    if port.isdigit():
                        processes = get_process_by_port(int(port))
                        if processes:
                            display_process_info(processes, True)
                        else:
                            print(f"端口 {port} 未被占用")
                    else:
                        print("请输入有效的端口号")

                elif choice == '2':
                    keyword = input("请输入搜索关键字: ").strip()
                    if keyword:
                        processes = search_process_by_keyword(keyword)
                        display_process_info(processes, True)
                    else:
                        print("请输入搜索关键字")

                elif choice == '3':
                    processes = get_all_processes()
                    print(f"系统中共有 {len(processes)} 个进程")
                    display_process_info(processes[:20], True)

                elif choice == '4':
                    pid_input = input("请输入要终止的PID (多个PID用空格分隔): ").strip()
                    if pid_input:
                        pids = []
                        for pid_str in pid_input.split():
                            if pid_str.isdigit():
                                pids.append(int(pid_str))

                        if pids:
                            for pid in pids:
                                try:
                                    process = psutil.Process(pid)
                                    process.terminate()
                                    print(f"已发送终止信号给进程 {pid}")
                                except Exception as e:
                                    print(f"终止进程 {pid} 时出错: {e}")
                        else:
                            print("未输入有效的PID")

                elif choice == '0':
                    print("退出程序")
                    break
                else:
                    print("无效选择，请重新输入")

            except KeyboardInterrupt:
                print("\n\n程序被用户中断")
                break
            except Exception as e:
                print(f"发生错误: {e}")


if __name__ == "__main__":
    # 检查是否安装了psutil
    try:
        import psutil
    except ImportError:
        print("错误: 需要安装psutil库")
        print("请运行: pip install psutil")
        exit(1)

    main()

运行效果：

记一次腾讯云报警『Lighthouse存在对外攻击的违规通知』

Fri, 30 Jan 2026 11:21:49 +0800

2026年1月29日晚上下班的时候，收到了腾讯云发来的邮件通知：Lighthouse存在对外攻击的违规通知，着实把我吓了一跳，以为服务器要被封禁了。

看到这个告警，我真是丈二的和尚摸不着头脑，这个服务器已经运行了好几年了一直没问题，怎么会突然报警呢？邮件中提到为什么会收到这个通知：通常是由于您的服务存在对外攻击、网络扫描、恶意爬虫、钓鱼网站、垃圾或钓鱼邮件、传播病毒木马、存在黑链或网站被篡改等违法违规行为。

也就是说我攻击别人网站被腾讯发现了？真是滑天下之大稽，我都不懂网络攻防好不好，别给我开玩笑了。跟着指引来到解决方案的页面：《安全违规处理帮助指引》，根据指引，我发现最有可能出现问题的就是我在服务器上安装的frp服务出了问题。

一、排查过程

根据腾讯云提供的排查文档：Linux 主机安全排查指引，一步一步排查是哪里出现的问题。

1、检查弱口令

我的服务器已经关闭了密码登录，只能根据RSA秘钥登录，除非我的秘钥泄露，否则不可能有人能登录我的服务器，通过last命令查看服务器近期登录的账户记录，确认是否有可疑 IP 登录过机器：

这几个ip地址都是我本地的ip地址，没有任何问题，说明不是非法登录导致的。

通过命令less /var/log/secure|grep 'Accepted'再次确认：

可以百分百确认没有问题。

2、检查恶意进程及非法端口

官方文档中有提到“排查设备是否搭建了网络代理服务（如 frp、HAProxy 等），被恶意利用作为对外攻击跳板”，正巧，我搭建了frp服务做内网穿透，frp 服务的日志非常诡异：

可以看到，这个日志显示了有个frp client中有个叫做test9080的配置每秒一次访问我的frp server，客户端ip地址是185.135.77.63，我的frp client并没有test9080的配置。。重启frp server，这个test9080会立马重新注册上来，查了下185.135.77.63这个ip地址：

百度智能云的结果：

没错，对方使用了VPN恶意注册到了我的frp server，不知道做了什么事情，被腾讯云检测出来我这台机器发起了网络攻击，所以被腾讯云警告了。

把日志下载下来，好好排查了一下，发现在2026年1月27日的时候，第一次出现了testXXX的访问记录：

2026/01/27 15:00:10 [1;34m[I] [service.go:449] [a02bb422d2875ddd] client login info: ip [185.135.77.63:63368] version [0.44.0] hostname [] os [windows] arch [amd64][0m
2026/01/27 15:00:10 [1;34m[I] [tcp.go:63] [a02bb422d2875ddd] [test9083.] tcp proxy listen port [7083][0m
2026/01/27 15:00:10 [1;34m[I] [control.go:446] [a02bb422d2875ddd] new proxy [test9083.] success[0m
2026/01/27 15:00:10 [1;34m[I] [tcp.go:63] [a02bb422d2875ddd] [test5556...] tcp proxy listen port [5556][0m
2026/01/27 15:00:10 [1;34m[I] [control.go:446] [a02bb422d2875ddd] new proxy [test5556...] success[0m
2026/01/27 15:00:10 [1;34m[I] [tcp.go:63] [a02bb422d2875ddd] [test9080...] tcp proxy listen port [9080][0m
2026/01/27 15:00:10 [1;34m[I] [control.go:446] [a02bb422d2875ddd] new proxy [test9080...] success[0m
2026/01/27 15:00:10 [1;34m[I] [tcp.go:63] [a02bb422d2875ddd] [test9082...] tcp proxy listen port [9082][0m
2026/01/27 15:00:10 [1;34m[I] [control.go:446] [a02bb422d2875ddd] new proxy [test9082...] success[0m

登录成功的ip地址正是185.135.77.63，同时它注册了好几个端口号到frp server。后来它换了好几个ip地址，其中有一个ip地址162.142.125.193被直接认定为攻击威胁ip地址：

毫无疑问，我的机器被当做肉鸡发起了对外的攻击，但是原理我还没搞明白。

3、FRP服务端被恶意利用作为攻击跳板的原理

大模型告诉我，攻击者并没有破解我的服务器密码，而是利用了我FRP服务端配置上的安全漏洞，将其变成了一个“公共代理”或“跳板服务器”。

攻击者的完整利用链条：

扫描发现：攻击者使用工具（如Shodan, Zoomeye, Fofa）全网扫描开放了7000端口的IP。
尝试连接：攻击者尝试用默认配置或常见的弱token连接我的的FRPS。
连接成功：由于我缺少认证或使用了弱token，攻击者成功将自己的FRP客户端连接到我的服务器上。
建立恶意隧道：攻击者在自己的FRP客户端配置中，设置类型为 socks5或 tcp的代理，指向他想攻击的目标。
发起攻击：攻击者所有的后续请求（DDoS流量、漏洞扫描、爬取数据、爆破其他服务）都经由我的FRP服务器转发出去。
后果：
- 受害者看到攻击流量全部来源于我的服务器IP。
- 我收到腾讯服务商的安全投诉，或被目标方的防火墙封禁IP。
- 我的服务器因转发大量攻击流量，可能产生高带宽消耗，甚至被服务商关停。
- 如果攻击行为触犯法律，我可能需要配合调查，证明自身也是受害者。

TCP代理隧道配置案例：

[common]
server_addr = B.B.B.B  # 你的FRP服务端
server_port = 7000
token = 你的密码（已被窃取）

[attack_proxy]
type = tcp
local_ip = C.C.C.C     # 关键：这里填第三方受害者的IP！
local_port = 80        # 关键：这里填第三方受害者的端口！
remote_port = 22222    # 在你的服务器上开启的端口

攻击流程：

攻击者在自己的机器上运行此配置
隧道建立后，所有发给 B.B.B.B:22222 的流量
都会被你的FRP服务端转发到 C.C.C.C:80
受害者看到的所有攻击都来自 你的服务器IP（B.B.B.B）

作为Socks5代理（更常见、更危险）案例：

[socks5_attack]
type = tcp
remote_port = 10808
plugin = socks5

攻击者建立Socks5代理隧道
设置浏览器、扫描器、攻击工具使用Socks5代理：B.B.B.B:10808
所有攻击流量先到你的服务器，再被转发给任意第三方目标
受害者只能溯源到你的IP

二、解决方案

我的frp服务器使用了默认的7000端口号，并且没有设置token验证导致攻击方利用漏洞将我的服务器恶意利用作为对外攻击跳板。解决方案就非常简单了：修改默认端口号并且加上token认证就好了。

frps配置修改：

# 修改默认的端口号
bind_port = xxxx
# 使用token认证
token = xxxx
# 添加端口号白名单
allow_ports = 8081,8082,8083...

对应的frpc配置修改：

# 修改服务端默认端口号
server_port = xxxx
# 使用token认证
authentication_method = token
authenticate_heartbeats = true
authenticate_new_work_conns = true
# 修改使用的认证token
token = xxxx
heartbeat_interval = 30
heartbeat_timeout = 90
login_fail_exit = true

依次重启服务端和客户端，再次观察日志，就可以发现对方已经无法注册上去了。

MySql8.0公共表表达式『CTE』

Tue, 28 Oct 2025 15:40:32 +0800

CTE是『common table expression』的缩写，中文翻译过来就是『公共表表达式』，使用它可以为临时查询结果命名，命名后可以在后续的查询语句中反复引用。CTE完整语法格式如下：

WITH [RECURSIVE]
    cte_name [(column_list)] AS (
        subquery
    )
    [, cte_name [(column_list)] AS (subquery)] ...
SELECT ... FROM cte_name ...;

『RECURSIVE』是递归的意思，但是它可选，表示CTE有两种模式：普通CTE和递归CTE。

以下内容节选自官方文档：https://dev.mysql.com/doc/refman/8.0/en/with.html#common-table-expressions-recursive-examples

一、普通CTE

普通CTE写法是最常用的写法，一个经典的写法如下所示：

WITH
  cte1 AS (SELECT a, b FROM table1),
  cte2 AS (SELECT c, d FROM table2)
SELECT b, d FROM cte1 JOIN cte2
WHERE cte1.a = cte2.c;

这个没什么好说的，非常简单，需要注意的是，不只是可以写select语句，还可以写update、delete语句：

WITH ... SELECT ...
WITH ... UPDATE ...
WITH ... DELETE ...

二、递归CTE

递归CTE是一种在查询中引用自身的写法，是处理层次结构或树形数据的强大工具。其完整语法如下所示：

WITH RECURSIVE cte_name [(column_list)] AS (
    -- 初始化查询提供初始结果集
    SELECT initial_columns
    FROM initial_table
    WHERE initial_condition
    
    UNION [ALL | DISTINCT]
    
    -- 递归部分
    SELECT recursive_columns
    FROM recursive_table
    JOIN cte_name ON join_condition
    WHERE recursive_condition
)
SELECT * FROM cte_name [OPTIONAL_CLAUSES];

递归CTE的子查询分为两部分，通过UNION [ALL | DISTINCT]连接：

SELECT ...      -- 非递归select语句，提供初始结果集，不引用CTE名字
UNION [ALL | DISTINCT]
SELECT ...      -- 递归select语句，引用CTE名字

需要注意的是基础部分和递归部分是通过UNION [ALL | DISTINCT]连接的，虽然语法上允许UNION DISTINCT去重，但是实际上几乎都是使用UNION ALL。

递归CTE语法有如下限制使用条件：

基础部分的列长度将会限制递归部分的列长度
递归select语句不能包含如下语句：聚合函数比如SUM()、窗口函数、GROUP BY、order by、distinct
递归select语句只能引用一次CTE，并且只能在from语句中使用，不能在任何子查询中使用；可以使用join语句与其它表连接，但是在这种使用场景中，CTE不能位于LEFT JOIN的右侧。

1、案例讲解

递归CTE不是很容易理解，下面通过几个案例来说明下：

案例1：打印1到5

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte WHERE n < 5
)
SELECT * FROM cte;

输出结果：

+------+
| n    |
+------+
|    1 |
|    2 |
|    3 |
|    4 |
|    5 |
+------+

首先执行基础查询部分 SELECT 1，生成初始结果集，此时CTE的结果为：[1]；

第一次递归迭代：从CTE中取出n=1，执行递归部分 SELECT n + 1 FROM cte WHERE n < 5，计算：1 + 1 = 2，，将结果2添加到CTE中，现在CTE的结果为：[1, 2]。

第二次递归迭代：从CTE中取出n=2，执行递归部分，计算：2 + 1 = 3，将结果3添加到CTE中，现在CTE的结果为：[1, 2, 3]。

第三次递归迭代：从CTE中取出n=3，执行递归部分，计算：3 + 1 = 4，将结果4添加到CTE中，现在CTE的结果为：[1, 2, 3, 4]。

第四次递归迭代：从CTE中取出n=4，执行递归部分，计算：4 + 1 = 5，将结果5添加到CTE中，现在CTE的结果为：[1, 2, 3, 4, 5]。

终止条件检查：下一次迭代时n=5，不满足WHERE条件 n < 5，递归终止。

所以，最终的查询结果就是[1, 2, 3, 4, 5]

案例2：重复字符串

在下面这个案例中，将要验证递归CTE的一个特性：基础部分的列长度将会限制递归部分的列长度。什么意思呢？看下面的sql语句：

WITH RECURSIVE cte AS
(
  SELECT 1 AS n, 'abc' AS str
  UNION ALL
  SELECT n + 1, CONCAT(str, str) FROM cte WHERE n < 3
)
SELECT * FROM cte;

正常来说，我们预测输出如下所示：

+------+--------------+
| n    | str          |
+------+--------------+
|    1 | abc          |
|    2 | abcabc       |
|    3 | abcabcabcabc |
+------+--------------+

但是在实际执行过程中，如果是严格模式下的运行，会提示报错：

错误代码： 1406
Data too long for column 'str' at row 1

如果是非严格模式下的运行，则会有结果如下所示：

+------+------+
| n    | str  |
+------+------+
|    1 | abc  |
|    2 | abc  |
|    3 | abc  |
+------+------+

结果总是和我们的预测不一样。这是因为在初始语句SELECT 1 AS n, 'abc' AS str中，'abc'字符串长度为3，这限制了之后的递归查询语句中的所有str列长度都是3，那么'abcabc'就存储不了了，在非严格模式下，结果会被截断，仍然是'abc'；在严格模式下，则会报错。

解决方案就是在初始语句中重新定义列长度：

WITH RECURSIVE cte AS
(
  SELECT 1 AS n, CAST('abc' AS CHAR(20)) AS str
  UNION ALL
  SELECT n + 1, CONCAT(str, str) FROM cte WHERE n < 3
)
SELECT * FROM cte;

通过CAST('abc' AS CHAR(20)) 将列长度扩展到了20，这样就能在接下来的递归中容纳的了abcabcabc了。

案例3：斐波那契数列

斐波那契数列的定义如下：

按照定义，前10个斐波那契额数列如下所示：0,1,1,2,3,5,8,13,21,34

写下sql打印如上斐波那契额数列：

WITH RECURSIVE cte AS 
(
SELECT 1 AS n,0 AS fn,1 AS fn_next
UNION ALL
SELECT n+1,fn_next,fn+fn_next FROM cte WHERE n<10
)
SELECT * FROM cte

案例4：日期序列生成

首先先创建表并插入数据：

-- 创建 sales 表
CREATE TABLE sales (
    DATE DATE,
    price DECIMAL(10,2)
);

-- 插入数据
INSERT INTO sales (DATE, price) VALUES
('2017-01-03', 100.00),
('2017-01-03', 200.00),
('2017-01-06', 50.00),
('2017-01-08', 10.00),
('2017-01-08', 20.00),
('2017-01-08', 150.00),
('2017-01-10', 5.00);

我们现在根据日期分组统计销售额：

mysql> SELECT date, SUM(price) AS sum_price
       FROM sales
       GROUP BY date
       ORDER BY date;
+------------+-----------+
| date       | sum_price |
+------------+-----------+
| 2017-01-03 |    300.00 |
| 2017-01-06 |     50.00 |
| 2017-01-08 |    180.00 |
| 2017-01-10 |      5.00 |
+------------+-----------+

虽然查询结果是对的，但是这并不是我想要的结果，我想要的结果应该是连续的日期，如果销售额为0则显示0，我想要的输出应该是这样：

+------------+-----------+
| date       | sum_price |
+------------+-----------+
| 2017-01-03 |    300.00 |
| 2017-01-04 |      0.00 |
| 2017-01-05 |      0.00 |
| 2017-01-06 |     50.00 |
| 2017-01-07 |      0.00 |
| 2017-01-08 |    180.00 |
| 2017-01-09 |      0.00 |
| 2017-01-10 |      5.00 |
+------------+-----------+

可以借助递归CTE实现该功能：

WITH RECURSIVE dates (date) AS
(
  SELECT MIN(date) FROM sales
  UNION ALL
  SELECT date + INTERVAL 1 DAY FROM dates
  WHERE date + INTERVAL 1 DAY <= (SELECT MAX(date) FROM sales)
)
SELECT dates.date, COALESCE(SUM(price), 0) AS sum_price
FROM dates LEFT JOIN sales ON dates.date = sales.date
GROUP BY dates.date
ORDER BY dates.date;

当然这个查询有些复杂，最重要的一部分是这部分sql：

WITH RECURSIVE dates (DATE) AS
(
  SELECT MIN(DATE) FROM sales
  UNION ALL
  SELECT DATE + INTERVAL 1 DAY FROM dates
  WHERE DATE + INTERVAL 1 DAY <= (SELECT MAX(DATE) FROM sales)
)
SELECT dates.date FROM dates

这部分sql生成了sales表中从最小日期到最大日期之间的所有日期列表：

+------------+
| date       |
+------------+
| 2017-01-03 |
| 2017-01-04 |
| 2017-01-05 |
| 2017-01-06 |
| 2017-01-07 |
| 2017-01-08 |
| 2017-01-09 |
| 2017-01-10 |
+------------+

然后通过左外连接sales表分组统计销售额，这样就实现了日期的连续列表。

COALESCE函数用于返回第一个不为NULL的值，在此处COALESCE(SUM(price), 0)的意思是如果没有销售额，则为0。

案例5：树状组织架构

接下来创建一个雇员表来演示树状组织架构：

CREATE TABLE employees (
  id         INT PRIMARY KEY NOT NULL,
  name       VARCHAR(100) NOT NULL,
  manager_id INT NULL,
  INDEX (manager_id),
FOREIGN KEY (manager_id) REFERENCES employees (id)
);
INSERT INTO employees VALUES
(333, "Yasmina", NULL),  # Yasmina is the CEO (manager_id is NULL)
(198, "John", 333),      # John has ID 198 and reports to 333 (Yasmina)
(692, "Tarek", 333),
(29, "Pedro", 198),
(4610, "Sarah", 29),
(72, "Pierre", 29),
(123, "Adil", 692);

执行完上述sql，表中内容如下所示：

+------+---------+------------+
| id   | name    | manager_id |
+------+---------+------------+
|   29 | Pedro   |        198 |
|   72 | Pierre  |         29 |
|  123 | Adil    |        692 |
|  198 | John    |        333 |
|  333 | Yasmina |       NULL |
|  692 | Tarek   |        333 |
| 4610 | Sarah   |         29 |
+------+---------+------------+

现在我们要写一个查询sql，用于查询每个雇员向上汇报的路径，其查询结果应当如下所示：

+------+---------+-----------------+
| id   | name    | path            |
+------+---------+-----------------+
|  333 | Yasmina | 333             |
|  198 | John    | 333,198         |
|   29 | Pedro   | 333,198,29      |
| 4610 | Sarah   | 333,198,29,4610 |
|   72 | Pierre  | 333,198,29,72   |
|  692 | Tarek   | 333,692         |
|  123 | Adil    | 333,692,123     |
+------+---------+-----------------+

查询sql如下：

WITH RECURSIVE employee_paths (id, name, path) AS
(
  SELECT id, name, CAST(id AS CHAR(200))
    FROM employees
    WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.name, CONCAT(ep.path, ',', e.id)
    FROM employee_paths AS ep JOIN employees AS e
      ON ep.id = e.manager_id
)
SELECT * FROM employee_paths ORDER BY path;

这个CTE语句从根节点（CEO）节点开始查找，查找谁的上级是CEO，然后依次递归查找，直到普通雇员为止，由于普通雇员不是谁的上级，所以JOIN语句会返回空，递归结束。

进阶问题1：查询Sarah的向上汇报路径，每个节点返回一条数据

WITH RECURSIVE employees_paths(id,NAME,manager_id) AS
(
SELECT id,NAME,manager_id FROM `employees`
WHERE NAME = 'Sarah'
UNION ALL
SELECT employees.id,employees.name,employees.manager_id FROM employees_paths 
JOIN `employees` ON employees_paths.manager_id = employees.`id`
)
SELECT * FROM employees_paths

查询结果：

    id  name     manager_id  
------  -------  ------------
  4610  Sarah              29
    29  Pedro             198
   198  John              333
   333  Yasmina        (NULL)

进阶问题2：查询John的所有下级节点

这个问题要求的是John的所有下级节点，由于子节点也有子节点，所以需要递归查询，查询sql如下：

WITH RECURSIVE employees_paths(id,NAME,manager_id) AS
(
SELECT id,NAME,manager_id FROM `employees`
WHERE NAME = 'John'
UNION ALL
SELECT employees.id,employees.name,employees.manager_id FROM employees_paths 
JOIN `employees` ON employees_paths.id = employees.`manager_id`
)
SELECT * FROM employees_paths

查询结果：

    id  NAME    manager_id  
------  ------  ------------
   198  John             333
    29  Pedro            198
    72  Pierre            29
  4610  Sarah             29

这个问题的查询sql和上一个问题的查询sql非常像，只是将连接条件互换了下，其结果就完全不一样了。

2、递归失控

如果递归终止条件设置的不正确，则会导致递归失控，看下面的案例sql：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte
)
SELECT * FROM cte

在mysql中执行上述语句，会提示如下报错：

错误代码： 3636
Recursive query aborted after 1001 iterations. Try increasing @@cte_max_recursion_depth to a larger value.

这意思是递归次数超过了系统限制，拒绝执行剩余递归查询。从报错上来看，系统默认设置的递归最大次数是1000次，可以在命令行中动态调整cte_max_recursion_depth的值设置最大递归次数，比如我执行了命令

SET SESSION cte_max_recursion_depth = 10

再次执行程序，报错提示就变成了：

错误代码： 3636
Recursive query aborted after 11 iterations. Try increasing @@cte_max_recursion_depth to a larger value.

另外，还可以设置 max_execution_time 值限制递归查询最大超时时间，单位是毫秒，默认值0表示无超时时间限制。

3、使用limit终止递归

在mysql8.0.19开始，mysql开始支持使用limit语句终止递归，比如在上面的查询中：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte
)
SELECT * FROM cte

由于没有设置递归终止条件，会在递归1000次以后，触发系统递归最大次数的阈值上限从而报错。通过limit语句也可以终止递归：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte LIMIT 1001
)
SELECT * FROM cte

这样会查询出来1到1001共1001个数。

Redis（十三）：Caffeine+Redis高性能二级缓存实现

Fri, 17 Oct 2025 17:33:06 +0800

上一篇文章《Redis（十二）：Java客户端之Spring Data Redis》最后讲了使用Redis作为缓存集成到SpringBoot，虽然Redis比较高效，但是相对于本地缓存来说效率还是比较低。本篇文章将基于Java21+Springboot3.5.4，使用Caffeine作为一级缓存，Redis作为二级缓存实现高性能二级缓存功能，并封装成SpringBoot Starter上传到Maven中央仓库。

一、SpringBoot Caching

SpringBoot中有个spring-boot-starter-cache组件，该组件是 Spring Boot 提供的用于简化缓存管理的 Starter 依赖，其核心作用是为 Spring 应用提供声明式缓存支持，通过抽象层统一不同缓存技术的使用方式，从而提升应用性能并降低开发复杂度。

spring-boot-starter-cache本身不实现具体缓存技术，而是通过 Spring Cache 抽象层（如 CacheManager和 Cache接口）支持多种缓存后端（如 Redis、Caffeine、EhCache 等）。开发者只需通过注解配置即可切换缓存实现，无需修改业务代码。通过 @EnableCaching注解启用缓存后，只需更换依赖（如从 ConcurrentMap切换到 Redis），Spring Boot 会自动配置对应的 CacheManager。

从上图可以看到，spring-boot-starter-cache组件没有任何代码，它只是通过pom文件将相关的依赖引入进来：

<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>3.5.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>6.2.9</version>
      <scope>compile</scope>
    </dependency>
</dependencies>

最重要的依赖就是spring-context-support，它是spring-context的扩展组件。

在使用的时候，

用户需显式引入所需的缓存库（如 caffeine或 spring-boot-starter-data-redis），Spring Boot 会根据依赖自动配置对应的 CacheManager。例如：

引入 caffeine后，Spring Boot 会生成 CaffeineCacheManager。
引入 Redis 后，会生成 RedisCacheManager

1、CacheManager

CacheManager类是Spring抽象出来的缓存管理器接口，从名字上就知道它是干什么的了：缓存管理器，似乎是专门管理缓存的，那我们猜测它应该有CRUD方法，实际它长什么样子呢？

可以看到该接口特别简单，它只提供了getCache和getCacheNames方法，和我们预想的它应该有CRUD方法有很大不同，为什么会这样子呢？

因为**动态缓存管理是特定于底层技术的，无法被完美抽象，Spring CacheManager 的核心职责不是一个缓存实例的管理器，而是一个缓存抽象的门面或访问点。**因此它没有将对缓存的具体操作抽象出来，具体的操作都封装到了Cache接口中，由不同的服务提供商实现。

RedisCacheManager不是必须的，以Redis为例，在我们使用spring-boot-starter-data-redis的时候，如果只是使用了RedisTemplate直接操作Redis，则RedisCacheManager就算不存在也没关系，因为这两者是服务于不同目的、不同抽象层次的工具，理论上可以完全独立使用。

特性	RedisTemplate	RedisCacheManager
抽象层级	命令式、底层操作	声明式、高层抽象
核心目的	提供一套丰富的、类型化的 API 来直接执行 Redis 命令（如 `opsForValue()`, `opsForHash()`）。	作为 Spring 缓存抽象的实现，将 `@Cacheable` 等注解的行为映射到 Redis。
使用方式	在代码中显式调用其方法，如 `redisTemplate.opsForValue().set("key", "value")`。	由 Spring 框架在背后自动调用，开发者通过注解来使用。
数据序列化	高度可控。可以为不同的操作（value, hash key, hash value等）单独配置序列化器。	通常为缓存值（Cache）统一配置序列化器，Key 的生成也遵循特定规则。
是否必需	是直接操作 Redis 的必需组件。	否仅在使用 Spring 的声明式缓存注解（`@Cacheable`等）时才需要。

如果我们想设计Caffeine+Reids二级缓存实现，并且使用Redis注解实现缓存功能，则自己实现CacheManager即可。那问题来了，是不是RedisCacheManager也会自动创建，如果自动创建了，那会使用哪个CacheManager呢？实际上应用程序只允许一个CacheManager存在，看看RedisCacheManager的配置（org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration）：

这里面有个很重要的注解：@ConditionalOnMissingBean(CacheManager.class)，意思就是如果我们自定义了CacheManager，就不会创建默认的RedisCacheManager了。这样我们自定义CacheManager就可以取而代之了。

2、Cache

Cache接口和CacheManager接口搭配使用，CacheManager对外提供统一的访问入口，对缓存的CRUD底层操作则依赖于Cache接口。可以这么认为：CacheManager 是一个工具箱，而 Cache 是工具箱里的一把把具体的工具（比如螺丝刀、锤子、扳手）。

特性	CacheManager (工具箱)	Cache (工具)
角色	容器、工厂、管理器	内容、产品、被管理对象
核心职责	1. 管理所有 `Cache` 实例的生命周期。 2. 根据名称提供（获取或创建）`Cache` 对象。 3. 对外提供统一的访问入口。	1. 定义缓存的基本操作接口（CRUD）。 2. 实际存储和访问缓存数据（键值对）。
关注点	“有哪些缓存？” “给我名叫‘A’的缓存”	“缓存里有什么？” “根据Key‘123’获取值”
方法	`Cache getCache(String name)` `Collection<String> getCacheNames()`	`ValueWrapper get(Object key)` `void put(Object key, Object value)` `void evict(Object key)` `void clear()`
类比	JDBC 中的 `DataSource`	JDBC 中的 `Connection`

由于我们要设计并实现Caffeine+Redis二级缓存架构，所以可以预想到的是必须自定义Cache并在里面实现二级缓存的CRUD功能。

3、@EnableCaching

@EnableCaching 和 spring-boot-starter-data-redis 提供的自动配置（Auto-Configuration）是两个完全独立的功能。@EnableCaching 只负责激活 Spring 的声明式缓存抽象层（即让 @Cacheable, @CacheEvict 等注解生效），spring-boot-starter-data-redis 负责自动配置所有与 Redis 连接和操作相关的基础设施 Bean，其中最核心的就是 RedisConnectionFactory。

这样，我们实现了自定义的CacheManager以及Cache，通过@EnableCaching注解就可以通过Spring原生注解方式使用我们的二级缓存了。

二、Caffeine

caffeine是最流行的本地缓存组件，被称为“本地缓存之王”。

github地址：https://github.com/ben-manes/caffeine

关于它的使用，可以参考其wiki：https://github.com/ben-manes/caffeine/wiki/Home-zh-CN

1、Caffeine的CRUD操作

首先加入Caffeine的依赖：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.2.2</version>
</dependency>

首先创建一个缓存实例：

private static Cache<String, Object> cache = Caffeine.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES) // 写入后10分钟过期
        .maximumSize(1000) // 最大缓存数量
        .build();

然后测试其CRUD功能

@Data
@AllArgsConstructor
public static class User {
    private String name;
}

@Test
public void testCRUD() {
    User user1 = new User("张三");
    User user2 = new User("李四");
    //添加到缓存
    cache.put(user1.getName(), user1);
    cache.put(user2.getName(), user2);
    //查询缓存中的信息
    System.out.println(cache.getIfPresent(user1.getName()));
    System.out.println(cache.getIfPresent(user2.getName()));
    //删除缓存中的信息
    cache.invalidate(user1.name);
    System.out.println(cache.getIfPresent(user1.getName()));
}

可以看到，其实Caffeine的使用非常简单，更多高级功能使用，可以参考wiki。

2、整合Caffeine到SpringBoot

在之前的一篇文章中讲了redis spring-boot-starter的使用，redis spring-boot-starter属于Spring Data家族的，关于Spring Data可以看看文档：https://spring.io/projects/spring-data

可以看到Spring Data支持Redis、ES、Mongo等组件，但是并不支持Caffeine，但是这并不意味着Caffeine无法集成到SpringBoot使用Spring Cache原生注解。之前已经分析过，要想SpringBoot支持使用Spring Cache的原生注解，需要创建CacheManager，实际上Spring已经帮我们做好了支持CacheManager的准备：

在spring-context-support模块，已经定义好了CaffeineCacheManager：org.springframework.cache.caffeine.CaffeineCacheManager

在spring-boot-autoconfigure模块，已经定义好了CaffeineCacheConfiguration：org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration

可以看到，只要引入了Caffeine的依赖以及spring-context-support的依赖，CaffeineCacheManager就会自动被创建。

需要注意的是，如果同时引入了Spring Data Redis和Caffeine，则Redis会优先生效，为了避免意外的缓存行为，推荐在实践过程中“明确配置”而非依赖默认行为。

基础使用

第一步：引入maven依赖配置：

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>3.5.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
        </dependency>
</dependencies>

spring-context-support会在引入spring-boot-starter-cache的同时被引入，所以不需要单独引入了。

第二步：使用Cache

package cn.kdyzm.component.cache.service;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author kdyzm
 * @date 2025/9/24
 */
@Service
public class UserService {

    private static final String CACHE_NAME = "users";

    @Data
    @AllArgsConstructor
    public static class User {
        private Long id;
        private String name;
    }

    @Cacheable(value = CACHE_NAME, key = "#id", unless = "#result == null")
    public User getUserById(Long id) {
        System.out.println("从数据库查询用户: " + id);
        return new User(id, "用户");
    }

    /**
     * 更新操作 - 清除缓存
     */
    @CacheEvict(value = CACHE_NAME, key = "#user.id")
    public User updateUser(User user) {
        System.out.println("更新用户并清除缓存: " + user.getId());
        return user;
    }

    /**
     * 删除操作 - 清除缓存
     */
    @CacheEvict(value = CACHE_NAME, key = "#id")
    public void deleteUser(Long id) {
        System.out.println("删除用户并清除缓存: " + id);
    }

}

第三步：测试

package cn.kdyzm;

import cn.kdyzm.component.cache.Application;
import cn.kdyzm.component.cache.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertNotNull;

/**
 * @author kdyzm
 * @date 2025/9/24
 */
@SpringBootTest(classes = {Application.class})
@Slf4j
public class CaffeineSpringBootTest {

    @Autowired
    private UserService userService;

    @Test
    public void testCache() {
        // 第一次查询 - 会访问数据库
        UserService.User user1 = userService.getUserById(1L);
        assertNotNull(user1);

        // 第二次查询 - 从缓存获取
        UserService.User user2 = userService.getUserById(1L);
        assertNotNull(user2);

        // 删除用户 - 会清除缓存
        userService.deleteUser(1L);

        // 再次查询 - 会访问数据库（因为缓存被清除了）
        UserService.User user3 = userService.getUserById(1L);
        assertNotNull(user3);
    }
}

配置参数

上述案例中并没有单独的配置文件配置，实际上可以对缓存行为进行配置：

spring:
  cache:
    caffeine:
      spec: maximumSize=500,expireAfterAccess=600s
    type: caffeine

这样配置很不方便，没有配置提示什么的，完整的配置有哪些参数可以参考类：com.github.benmanes.caffeine.cache.CaffeineSpec。

完整的配置参数如下所示：

配置键 (Key)	数据类型	说明	默认值	语法示例
initialCapacity	`int`	设置缓存的初始容量（空间大小）。	`UNSET_INT` (-1)	`initialCapacity=100`
maximumSize	`long`	设置缓存的最大条数（基于条目数量驱逐）。注意：与 `maximumWeight` 互斥。	`UNSET_INT` (-1)	`maximumSize=1000`
maximumWeight	`long`	设置缓存的最大权重（基于权重驱逐，需配合 `weigher` 使用）。注意：与 `maximumSize` 互斥。	`UNSET_INT` (-1)	`maximumWeight=200000`
expireAfterAccess	`Duration`	设置最后一次访问（读取或写入）后的过期时间。	`null`	`expireAfterAccess=10m`
expireAfterWrite	`Duration`	设置最后一次写入后的过期时间。	`null`	`expireAfterWrite=1h`
refreshAfterWrite	`Duration`	设置写入后多久自动刷新缓存值（需配置 `CacheLoader`）。	`null`	`refreshAfterWrite=30s`
weakKeys	`boolean` (无值)	将键（Key）设置为弱引用，允许JVM在内存不足时回收键。	`false` / `null`	`weakKeys`
weakValues	`boolean` (无值)	将值（Value）设置为弱引用，允许JVM在内存不足时回收值。注意：与 `softValues` 互斥。	`false` / `null`	`weakValues`
softValues	`boolean` (无值)	将值（Value）设置为软引用，在JVM内存不足时优先回收。注意：与 `weakValues` 互斥。	`false` / `null`	`softValues`
recordStats	`boolean` (无值)	开启缓存统计功能（如命中率），可通过 `Cache.stats()` 获取。	`false`	`recordStats`

自定义CaffeineCacheManager

官方默认创建CaffeineCacheManager的代码位于org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration，如果觉得spring官方提供的配置Caffeine的方式不方便，可以自定义创建方式，从而取代官方的创建方式。

    @Bean
    CaffeineCacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .recordStats()
                .xxxx
        );
        return cacheManager;
    }

这样就可以自定义配置文件的格式灵活配置CacheManager了。

创建独立使用的Caffeine Cache

上述创建CaffeineCacheManager的方法适用于SpringCache缓存注解使用，如果想直接操作Caffeine，则需要创建一个新的客户端。值得注意的是Caffeine的所有操作都是线程安全的，所以只需要全局创建一个单例实例即可：

    @Bean
    public Cache<String,Object> caffeineCache(){
        return Caffeine.newBuilder()
                .initialCapacity(xxx)//初始大小
                .maximumSize(xxx)//最大数量
                .expireAfterWrite(xxx)//过期时间
            	.xxx
                .build();
    }

三、二级缓存架构实现

接下来使用Caffeine作为一级缓存，Redis作为二级缓存实现多级缓存功能，其查询架构如下所示：

我的目标是实现一个基于Java21+Springboot3.5.4的SpringBoot Starter组件，名字为cache-spring-boot-starter，最终实现实现功能：可独立开启Caffeine、Redis或者二级缓存三种功能模式，三种模式下均支持SpringCache基于注解的缓存架构，暴露统一独立操控缓存API。

我将相关功能封装成了一个组件，并发布到了gitee：https://gitee.com/kdyzm/cache-spring-boot-starter ，该组件已经上传到了中央仓库（ https://central.sonatype.com/artifact/cn.kdyzm/cache-spring-boot-starter ），GAV坐标如下：

<dependency>
    <groupId>cn.kdyzm</groupId>
    <artifactId>cache-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

由于组件使用java21+Springboot3.5.4，所以在测试的时候需要搭建相应环境的项目，这里已经搭建好了测试环境，可以直接拉下来测试：https://gitee.com/kdyzm/cache-spring-boot-demo

1、配置文件

在pom.xml中引入cache-spring-boot-starter的依赖后，配置下配置文件如下：

spring:
  data:
    redis:
      database: 1
      password: 123456
      host: localhost
      port: 6379
  cache:
    redis:
      time-to-live: 5s
    caffeine:
      spec: maximumSize=500,expireAfterAccess=600s
      #配置了spec，则所有其它配置都将无效
      expire-after-access: 5s
      #caffeine其它配置

logging:
  level:
    cn.kdyzm.component.cache: DEBUG
#    org.springframework.cache: TRACE
#    org.springframework.data.redis: DEBUG

其配置和原生spring-boot-starter-cache和spring-boot-starter-data-redis是一模一样的，特别需要注意的是spring.cache.caffeine的spec配置，它原生的配置是一段字符串，格式是这样的：maximumSize=500,expireAfterAccess=600s,...，为了方便使用，我将其抽离出来形成一个个单独的配置，格式如下：

spring:
  cache:
    caffeine:
      expire-after-access: 5s
      maximum-size: 500
      ......

这样配置就和spec配置冲突了，所以代码里有约定：如果spec有值，则完全使用spec的配置；否则将使用其它独立的配置。

2、激活缓存配置

这里提供了三种不同的注解，用于激活不同的功能项：

@EnableCaffeineCache：仅使用Caffeine本地缓存。

@EnableRedisCache：仅使用Redis缓存

@EnableMultipleCache：使用Caffeine+Redis二级缓存。

将注解加在启动类上即可：

@SpringBootApplication
//@EnableMultipleCache
//@EnableCaffeineCache
//@EnableRedisCache
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

项目启动后会打印当前使用的CacheManager：

需要注意的是，如果不使用以上三种自定义注解，使用@EnableCaching注解，则会退回使用原生spring-cache相关功能。

3、业务代码中使用

配置完成之后，就可以在代码中使用了，使用方式和spring-cache注解方式是一模一样的，案例如下：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author kdyzm
 * @date 2025/9/24
 */
@Service
public class UserService {

    private static final String CACHE_NAME = "users";

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class User {
        private Long id;
        private String name;
    }

    @Cacheable(value = CACHE_NAME, key = "#id", unless = "#result == null")
    public User getUserById(Long id) {
        System.out.println("从数据库查询用户: " + id);
        return new User(id, "用户");
    }

    /**
     * 更新操作 - 清除缓存
     */
    @CacheEvict(value = CACHE_NAME, key = "#user.id")
    public User updateUser(User user) {
        System.out.println("更新用户并清除缓存: " + user.getId());
        return user;
    }

    /**
     * 删除操作 - 清除缓存
     */
    @CacheEvict(value = CACHE_NAME, key = "#id")
    public void deleteUser(Long id) {
        System.out.println("删除用户并清除缓存: " + id);
    }

}

4、测试二级缓存功能

拉取代码仓库代码：https://gitee.com/kdyzm/cache-spring-boot-demo，使用@EnableMultipleCache注解激活二级缓存功能，配置好配置文件中redis的链接，之后就可以测试二级缓存功能了。

在正式测试前，将spring.cache的ttl的配置先全部注释掉，以方便测试。

第一步：测试缓存保存功能

调用接口：http://localhost:8080/test/testGet ，观察日志输出

可以看到，由于没有缓存，所以会去查询数据库，之后再调用Cache的put方法将数据保存到一级缓存、二级缓存，同时触发Redis消息队列发消息，通知其它服务缓存变更，更新一级缓存（二级缓存已经由本服务更新）。

第二步：重复调用，测试缓存是否生效

再次调用接口：http://localhost:8080/test/testGet ，观察日志输出

可以看到，没有再查询数据库，直接从缓存中查询到了数据并返回了，缓存生效了。

第三步：验证二级缓存

前一步缓存已经生效了，如何验证它获取的是一级缓存的数据还是二级缓存的数据呢？当然可以debug代码，其实还有个更简单的方法，那就是重启服务。由于caffeine使用的是本地缓存，重启后将会失效，所以理论上来说重启后再次调用接口，服务不会从数据库获取，而是从redis一级缓存中获取数据。

重启服务后，重新请求接口：http://localhost:8080/test/testGet ，观察日志输出：

可以看到，并没有请求数据库。caffein从redis二级缓存中获取到了数据。

为了更直观的看到使用的是一级缓存，将redis中的数据删除：

删除后，重新请求 http://localhost:8080/test/testGet ，观察日志：

可以看到还是从缓存中获取了，观察redis，却没有新增key，说明当前缓存使用的是一级缓存caffeine。

四、技术细节

1、通过注解隔离三种缓存模式

通过三种注解

@EnableMultipleCache
@EnableCaffeineCache
@EnableRedisCache

开启三种不同的缓存模式，本质上是通过注解中的@Import功能激活相对应的Configuration：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(MultipleCacheConfiguration.class)
public @interface EnableMultipleCache {
}

每个Configuration是相互隔离的，并不会同时生效。

2、多级缓存的实现

实际上核心就是自定义CacheManager以及自定义Cache，对应着代码中的 MultipleCacheManager 以及 MultipleCache 。

MultiCacheManager用于根据CacheName查询对应的MultipleCache对象，实际的缓存CRUD都通过MultipleCache对象实现。

MultipleCache类并没有直接实现Cach接口，而是通过继承AbstractValueAdaptingCache类实现，这是借鉴了CaffeineCache、RedisCache的实现，通过继承该抽象类，可以减小实现难度。

3、缓存一致性

缓存一致性需要分具体场景讨论。

场景一：分布式场景下，服务A有两个实例，实例1通过接口从数据库取出数据并添加到了缓存，所以实例1的一级缓存和二级缓存都有了，但是实例2只有二级Redis缓存，一级缓存缺失。

解决方式是通过Redis发布订阅模式，当实例1添加缓存之后，立即通过消息队列通知其它服务，其它服务得到消息后构建一级缓存。

相对于新增一级缓存，缓存的失效同步更加重要，消息一共有三种类型：缓存更新、缓存失效、缓存全部失效。具体可看类：MsgCacheActionType

场景二：Redis发布订阅失效，场景1中实例2没接收到更新的消息，对于新增的场景来说，一级缓存可以从二级缓存中取出数据保存到一级缓存达成缓存一致性；对于缓存失效的场景来说会出现一致性问题。

所以最佳实践是一级缓存一定要设置有效期，这样可以达到最终一致性。

场景三：一级缓存和二级缓存的有效期不同，导致两个缓存可能会各自独立存在一段时间，出现缓存一致性问题。

我们追求的是最终一致性，所以短暂的缓存不一致是可以接受的。二级缓存是多服务共享的，所以不必担心，一级缓存只要设置了有效期，其必定会和一级缓存同步。

在 RedisCacheSynMessageReceiver 类中实现了对一级缓存的同步。

END.

2025新版Maven中央仓库发布jar包教程

Fri, 17 Oct 2025 11:16:50 +0800

本文转载自发布Jar到Maven中央仓库--Maven版(最新方式)

Maven发布jar包到中央仓库的方式发生了变化，之前的教程（上传jar包到maven中央仓库）部分失效了，https://oss.sonatype.org已经不再支持新用户注册，新的注册地址为 https://central.sonatype.com 。如果按照之前的教程推送jar包，会得到一个403响应。下面说下新版发布方式。

摘要

新版 Maven 中央仓库发布流程主要改变在于通过 Central Portal 进行，不再使用传统的 Jira 注册方式。你需要注册 Sonatype 账号并创建或验证命名空间，生成发布 Token 替代旧的用户名和密码进行认证，然后通过配置 Maven 的 settings.xml 和 pom.xml 文件，使用 GPG 生成签名密钥，最后打包并上传到中央仓库。

新版本推送方式从注册到验证到发布，都在统一的网站 https://central.sonatype.com ，实际上比以前的发布方式要简单的多。

一、将项目推送到远程仓库，如 `Github`或者`Gitee`

二、注册 `Sonatype` 账户

进入 https://central.sonatype.com 注册一个账号，邮箱要真实。

三、登录 Sonatype 创建`Namespace`

进入 Namespace 模块，然后点击 Add Namespace 按钮，Namespace 具有唯一性。发布前一定要创建Namespace，实际上就是项目的Group Id，因为要进行验证，所以这里不能随便填写，你可以配置为你拥有的域名，比如我的域名是hanqunfeng.com，这里就填写com.hanqunfeng。域名的验证方法是配置DNS TXT记录。

如果你没有域名，也可以使用Github的域名，比如我的Github用户名是hanqunfeng，则这里可以配置为io.github.hanqunfeng。Github的验证方式是根据给定个名称创建一个public repository。

四、发布

1.准备签名

方法一：可以使用工具创建密钥对 需要下载一个签名工具，我是mac电脑，下载的是https://gpgtools.org。安装后点击新建，按照提示创建一个密钥对即可，注意高级选项里有个过期时间，默认是3年。创建好后会主动提示你是否将公钥发布到key server，点击Upload Public key即可。也可以在创建后的证书列表页面邮件选择证书–>Send Public Key To Key Server。

导出证书时，勾选密码并设置密码就是私钥和公钥证书，不勾选密码就是公钥，看生成文件的名称就可以，公开就是公钥，私密就是私钥，格式都是asc，其实就是字符串，可以用记事本打开查看。

如果windows系统，可以下载https://www.gpg4win.org/ ，使用方式差不多，最后点击“将公钥上传的目录服务”。

公钥发布到key server后要稍微等一会，大约10分钟吧，因为key server有多个，同步需要一些时间。记住你创建密钥对时的密码，发布项目时要使用。

方法二：也可以使用命令行创建密钥对，版本[gpg (GnuPG/MacGPG2) 2.2.24]

# 创建密钥对，按提示输入用户名称和邮箱地址
gpg --generate-key

# 列出密钥，hanqunfeng就是创建密钥对是的用户名，此处也可以使用邮箱
# 结果中第二行一长串的后8位就是keyId，比如：30FF8D58，gradle构建时会用到
gpg --list-keys hanqunfeng
# 也可以直接通过id查询
gpg --list-keys 30FF8D58

# 上传公钥到server key，默认上传到hkps://keys.openpgp.org，但是提示上传失败
# 看到网上的示例可以通过--keyserver指定上传的服务器地址，但是我这个版本[gpg (GnuPG/MacGPG2) 2.2.24]没有这个参数
# 使用 https://gpgtools.org 上传公钥就会成功
gpg --send-keys 30FF8D58

# 查看指纹
gpg --fingerprint 30FF8D58

# 删除私钥，这里也可以使用用户名称或者邮箱，如果唯一的话
gpg --delete-secret-keys 30FF8D58

# 删除公钥
gpg --delete-keys 30FF8D58

2.settings.xml

配置 maven 的 settings.xml 文件，设置一个 server，里面添加 User Token。

登录https://central.sonatype.com后点击右上角的用户名称–> View Account --> Generate User Token

<settings>
    [...]
    <servers>
       [...]
       <server>
          <id>maven-central</id>
          <username>username</username>
          <password>token</password>
       </server>
    </servers>
</settings>

3.pom.xml

重点是后面几个plugin 这里重点说一下central-publishing-maven-plugin这个插件，该插件会将jar包推送到Maven Central仓库，如果插件没有配置参数autoPublish为true，则但此时发布的jar会处于VALIDATED状态，需要登录https://central.sonatype.com后切换到Deployment，找到我们刚刚上传的包名，然后点击右侧的Publish按钮，如果一切顺利，大于10分钟后其状态变为PUBLISHED，表示发布成功。如果发布失败，其状态会变更为FAILED，可以在Component Summary中查看失败原因，重新发布即可。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>io.github.hanqunfeng</groupId>
    <artifactId>aws-s3-v2-tools</artifactId>
    <version>1.0.1</version>
    <packaging>jar</packaging>
    <name>aws-s3-v2-tools</name>

    <description>
        AWS S3 Tools.
    </description>
    <url>https://blog.hanqunfeng.com</url>
    <licenses>
        <license>
            <name>The Apache License, Version 2.0</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
        </license>
    </licenses>
    <developers>
        <developer>
            <id>hanqf</id>
            <name>hanqunfeng</name>
            <email>qunfeng_han@126.com</email>
        </developer>
    </developers>
    <scm>
        <connection>scm:git:https://github.com/hanqunfeng/aws-s3-v2-tools.git
        </connection>
        <developerConnection>
            scm:git:https://github.com:hanqunfeng/aws-s3-v2-tools.git
        </developerConnection>
        <url>https://github.com/hanqunfeng/aws-s3-v2-tools</url>
    </scm>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.23.10</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
        </dependency>

        <!-- 为避免Potential Conflicts，你应该将commons-logging.jar从classpath中删除。你可以尝试从项目依赖中排除commons-logging，这样你的应用程序就会被强制使用Spring JCL而不是Commons Logging。 -->
        <!-- 问题：Standard Commons Logging discovery in action with spring-jcl: please remove commons-logging.jar from classpath in order to avoid potential conflicts -->
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3-transfer-manager</artifactId>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>aws-crt-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <version>1.18.32</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.29</version>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <id>attach-source</id>
                        <phase>verify</phase>
                        <goals>
                            <!--生成源代码的jar -->
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <id>attach-javadoc</id>
                        <phase>verify</phase>
                        <goals>
                            <!--生成javadoc的jar -->
                            <goal>jar</goal>
                            <!--生成javadoc的html -->
                            <goal>javadoc</goal>
                        </goals>
                        <configuration>
                            <!--不显示javadoc警告-->
                            <additionalOptions>-Xdoclint:none</additionalOptions>
                            <additionalJOption>-Xdoclint:none</additionalJOption>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- gpg plugin,用于签名认证 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-gpg-plugin</artifactId>
                <version>1.6</version>
                <executions>
                    <execution>
                        <id>sign-artifacts</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>sign</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- 发布到私服时需要注释掉下面两个插件 -->
            <!--staging puglin,用于自动执行发布阶段(免手动)-->
            <plugin>
                <groupId>org.sonatype.central</groupId>
                <artifactId>central-publishing-maven-plugin</artifactId>
                <version>0.5.0</version>
                <extensions>true</extensions>
                <configuration>
                    <!-- 这里的publishingServerId是在settings.xml中配置的server认证信息 -->
                    <publishingServerId>maven-central</publishingServerId>
                    <!-- 这里的autoPublish是自动发布，而不是手动发布 -->
                    <autoPublish>true</autoPublish>
                    <!-- 这里的waitUntil配置为published是等待发布完成，因为发布完成的时间比较长，所以可以不加这个参数 -->
                    <waitUntil>published</waitUntil>
                    <!-- 这里的deploymentName是发布到中央仓库的名称 -->
                    <deploymentName>${project.groupId}:${project.artifactId}:${project.version}</deploymentName>
                </configuration>
            </plugin>
            <!-- release plugin,用于发布到release仓库部署插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-release-plugin</artifactId>
                <version>2.5.3</version>
            </plugin>



        </plugins>
    </build>

    <distributionManagement>
        <!--        <repository>-->
        <!--            <id>maven-releases</id>-->
        <!--            <name>Nexus Release Repository</name>-->
        <!--            <url>http://nexus.cxzh.ltd:8081/repository/maven-releases/</url>-->
        <!--        </repository>-->
        <!--        <snapshotRepository>-->
        <!--            <id>maven-snapshots</id>-->
        <!--            <name>Nexus Snapshot Repository</name>-->
        <!--            <url>http://nexus.cxzh.ltd:8081/repository/maven-snapshots/</url>-->
        <!--        </snapshotRepository>-->

    </distributionManagement>
</project>

4.执行命令

mvn clean package # 完成打包和测试
mvn clean verify  # 完成源码打包和javadoc打包，同时完成签名
mvn clean deploy  # 完成本地部署和maven中央仓库部署

执行过程中会提示你输入创建密钥对时的密码，如果不想人工参与，也可以使用如下方式（参考：http://maven.apache.org/plugins/maven-gpg-plugin/usage.html）

在执行命令时指定密码：

mvn clean deploy -Dgpg.passphrase=thephrase

setting.xml中创建一个server

<settings>
[...]
<servers>
    [...]
    <server>
    <id>gpg.passphrase</id>
    <passphrase>clear or encrypted text</passphrase>
    </server>
</servers>
</settings>

5.更新部署

修改pom.xml中的版本号，重新执行mvn clean deploy即可。发布的jar包可以在https://central.sonatype.com中检索。

IntelliJ IDEA 2025.2 Maven设置不生效的解决方案

Fri, 26 Sep 2025 10:55:04 +0800

前些日子升级了IDEA到2025.2，使用了一段时间之后出现了一些问题，尤其让我头疼的问题就是Maven的配置总是失效，需要重新配置。

一、问题重现

后端有很多个微服务，我每次都是对着文件夹右键打开代码仓库：

升级IDEA到2025.2之后重新配置了maven设置，但是一旦重新打开新项目，maven设置就会失效，默认使用IDEA内置的maven（此时部分项目运行的时候会提示Groovy错误）。这是为什么呢？

二、问题分析

为了搞清楚这是不是新版的bug（老版2020.2没有这个问题），我在社区提了一个bug：https://youtrack.jetbrains.com/issue/IDEA-378154

原来，File->Settings->Build,Execution,Deployment->Build Tools->Maven 设置并非全局设置，而是只针对于当前项目的“局部配置”，这种当前项目的配置都有特殊的符号，如下所示：

三、解决问题

社区给了解决方案，那就是到File->New Projects Setup->Settings For New Projects，在里面配置的Maven设置将应用于新建的项目。

需要注意的是，有可能设置好了之后打开项目Maven设置还是内置的Maven，这表示在设置Settings For New Projects前你使用IDEA打开过项目，已经生成了项目配置文件，所以即使设置了Settings For New Projects，IDEA也不会应用新项目设置。这时候只需要删除项目根目录的.idea目录以及.iml文件，然后重新打开项目就可以了。

Diskgenius 破解版下载

Mon, 25 Aug 2025 09:04:25 +0800

下载地址：https://clamowo.lanzoui.com/b05agns3g

转载自：https://weilining.github.io/251.html

JetBrains系列软件2025.2版本激活教程

Fri, 15 Aug 2025 22:50:40 +0800

第一步：安装新版本软件

在彻底卸载旧版JetBrains软件之后，去官网下载软件并安装：

webstorm下载：https://www.jetbrains.com/webstorm/download/?section=windows

pycharm下载：https://www.jetbrains.com/pycharm/download/?section=windows

IntelliJ IDEA下载：https://www.jetbrains.com/idea/download/?section=windows

按部就班完成安装以后，不要运行软件。

第二步：激活软件

下载激活工具：激活工具，下载完成后解压文件，注意要将解压后的文件夹放到一个固定目录，不能删除或移动目录，否则会导致激活激活后失效。

打开scripts目录，运行install-current-user.vbs脚本，会有个弹框提示：

这意思是激活可能会耗费一些时间，点击确定按钮之后要耐心等待新的弹框提示：Done。实测我的激活时间比较久可能得有三五分钟，块的话可能得有五秒钟就行了，激活完成后有弹框提示：

第三步：输入激活码

打开安装好的软件：

点击"Skip Import"，进入如下页面，点击左下角的设置图标：

选择“Manage Licenses ”，进入激活管理页面，点击"Activation code"：

根据不同的产品选择不同的激活码，激活成功的页面：

不同产品的激活码不同，具体如下所示：

IDEA 激活码

FV8EM46DQYC5AW9-eyJsaWNlbnNlSWQiOiJGVjhFTTQ2RFFZQzVBVzkiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQUlIiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBEQiIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFNJIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJJSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6ZmFsc2V9XSwibWV0YWRhdGEiOiIwMjIwMjQwNzAyUFNBWDAwMDAwNVgiLCJoYXNoIjoiMTIzNDU2NzgvMC01NDE4MTY2MjkiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwidHJpYWwiOmZhbHNlLCJhaUFsbG93ZWQiOnRydWV9-cH8qBniG31nF8954hthJJuzF6Fk4RQ9T03IfNxsFkuxUcwaAGHKOcRudvBZIAbLwDDFw63q2QZsnpwthBb/6IqBYnJrjRC83a8wkYKGN8HqAyDtbqdLOxLjcaiAiSKzektfAXn6nGNfDeygcFr/WzMfI0on/43ByuwxmSrjwYc4M8SCR0nkDAi0XwXNnFp3vSp0gJQd+lJtkSHO2KR7gUyNDZOPVduljJGbdLJUK6UcUjrlAd6NrTNqpu5P7hcYRaNzjoJ0KeIx5k9KmMCdcfQBia/zSHUbwZiecFsyjxqtIU0C3TDaX1OM4siJVDpgrXi+ocY86hiiYE79ygJf2IA==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

PyCharm 激活码

GAJWL09BT5RSXDR-eyJsaWNlbnNlSWQiOiJHQUpXTDA5QlQ1UlNYRFIiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQQyIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlBTSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wLTQ2MTc4NjQwOSIsImdyYWNlUGVyaW9kRGF5cyI6NywiYXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwiaXNBdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJ0cmlhbCI6ZmFsc2UsImFpQWxsb3dlZCI6dHJ1ZX0=-UeOCCiS72PGvOIS9go0yIhDFVmPBvbKM56D9w0adVaGcYLtC7YxNr/5MQ/3+Mr05tQQAhMz12vBTb9sjJAXBo+HBzCv1o9IFZnJK2rf3pCXl83ulriBUQ6M0H6GUUy+Mc1fl0EGWquoNExZMujCkReWoeabxwwKPNCvHqHqkW1rU/+cwiVKjVfbIgQW9aChIwyYwexzSlM0TlHvQGfncEzI0+uYNxjRQUjemLlGJooYD0ycSMMTyTvM95QHi25DZjmQRkdzIhDA2l4uPp+C+XEAIdIST2rjEPolvJGcVu7P/DI77LDDqZwLtD8mFXh9lFqMEw9titvy4mYFlYp/xaw==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

DataGrip 激活码

54H0PAD972IO7OS-eyJsaWNlbnNlSWQiOiI1NEgwUEFEOTcySU83T1MiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBEQiIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiREIiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOmZhbHNlfSx7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOnRydWV9XSwibWV0YWRhdGEiOiIwMjIwMjQwNzAyUFNBWDAwMDAwNVgiLCJoYXNoIjoiMTIzNDU2NzgvMC00MTI3ODYxMTYiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwidHJpYWwiOmZhbHNlLCJhaUFsbG93ZWQiOnRydWV9-kOcI3r7/OB1foH2R44HwHoAZJfdfTo0y7c1AZF/I9SBxiyNErjzyyFslUgkOD7XqHzhBgy53J2edgvSVy0DhmNswVK8V5YSXO+SLQc0RrQkZy43fb1fbLK26+LHj8gUUkFZuUwlDaXIb3D6SWyWx6tXAFet0ot6O7+lwZ/vGrRDXVdpaL/LBuCVt1pz2a77orzxWKbtgLNmVLVRGi7sFpUgv5syvGDgWG0gClSZHiAyEDzvoGdAJ3e8Y4LDBInHxrGwZYx7uY50lRBewjLvitbfzFm9dVz5bM9+3g+jSlXzKF5aZ9x2TyeGiOy9snk0QpnyGkudLECvI5vM8drRIIw==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

WebStorm 激活码

1Z9RTLFFQRXP923-eyJsaWNlbnNlSWQiOiIxWjlSVExGRlFSWFA5MjMiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJXUyIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlBTSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wNzY0Njg1NzM3IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsInRyaWFsIjpmYWxzZSwiYWlBbGxvd2VkIjp0cnVlfQ==-bDIQ6Ihy8nWMd6+TEQxRYY2FDAO5yhA1knCEpdqRbstNWI78rmC/WTYm8PFmDK2QEEE7uawIblm6c2FAXLrLzkA7R+V3G+q/xZyYPGftNp4n7mW+VT35+t131R5UvTIoQNzf3dCJDFBD2fiJwDNgUzdwEKEjagjNLlSk5HQam3wZh8+x8aao2yEzgoBHgGrs+8Y8BHKecS9eZImboDJ+e8cT+JI92nNCx1IhPgVJDieNKlbYbCxJ9HgvHFUMSrkh0MPORn9IxmKLt6ssMU2kEMWR4HqcQjUgGRzt8cWJh0nihrqBlDFZwfKQj25oK07vAu22ysN4CkcNRyMcJBBP9A==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

CLion 激活码

I1EKS18DJA9M4KU-eyJsaWNlbnNlSWQiOiJJMUVLUzE4REpBOU00S1UiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJDTCIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlBTSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wMzMxNTgxNTM4IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsInRyaWFsIjpmYWxzZSwiYWlBbGxvd2VkIjp0cnVlfQ==-aBxu18kI8ObI+2malKBqZXqpCPT2T7+0adYDU0HBQMeY1J+M/lDGpdQjpDnlDWW3W7wb4QbES3TXl8kKRrVG8LgtwVg9DhtNSWcolfL0R5x73smRjZQB5Jfv4fwBtBu+I4fTrkP9HAwciOIKO3iyI8wsH8HVGR9AXgpl/wTLCSlj8/7IBAFz6wN8mgSdxV6ReEGSjQSDSevdQUbsFkq3LVYG9EXVvleltbdFq7wqVCmvmcnW1idgfDKzJrwlxtJRiLZoZIoEFJ/PXcivuKTJyiqKlDfOuaPt6wZU+aqw/xB5dBS51rzD8UwoLcnN5zlG5WwQPWZja1/UwTokUxR8Gw==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

PhpStorm 激活码

LK57VMVACTAYXFP-eyJsaWNlbnNlSWQiOiJMSzU3Vk1WQUNUQVlYRlAiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQUyIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlBTSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wOTIwNDIzMTY5IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsInRyaWFsIjpmYWxzZSwiYWlBbGxvd2VkIjp0cnVlfQ==-giMzZfCCESsBnJddcEgB017IbEg9bfmvITIA+KzajF26fvSBLHtN5qGuPNtAFuB1hPoRvAb4Xqj8rSrIfD0sDxF2ZwS4rkTsqbVRFz70y5+j1yFg7L2Z0g6pw5RNt2fkaYJ2s2T6522tWGcNKEQYDEOaH4JftAB3b66ht7kymV+fdNsD3ffa0TZUke+GfK0wcrJxUtePCUHQV3DsbKxLPERLLoGp19si57cDrZNZwMEUPDphDW5nesd0SAWgYEQSx2CN/0CJOZE9wCvyHETmpBShyOt5Lgq02Ve9jIfn/ARTFEeFXtbVrYSbTOARabhJ9duWKs+v2CiwcuEKLV9mrg==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

GoLand 激活码

BPTY4JK1CO0P29R-eyJsaWNlbnNlSWQiOiJCUFRZNEpLMUNPMFAyOVIiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJHTyIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlBTSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wLTIxMzg4MjAwMjAiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwidHJpYWwiOmZhbHNlLCJhaUFsbG93ZWQiOnRydWV9-OhYvoISC/Bq2JPS8zO7RMvG6+V3z3Cw2tIhUfU0rpcWF5H8LimtMCO4Vdw69OYo3VfeBJkoDm0Lu4fwPOllxlx5gbpwerW2pJCubD/TnfDlxK+gt9rUSihL2mCU4k66VB+8NOLdYSH7zukG8ghtbNoeE4BuAiFP6BLTSEipOy2SKKybEzQ1JArnqJyXa66SrxTegCkz8QSwqaBAtJHaBIJ+1MmnQ8y5wjBXXQJ/+9W8AyaxKM14dKvqYxxcf71PDfgzl12taubbpyL4DzGYUiu5cAdjfpqdx2ZEoalj+IW3M3FWB+2eTzHZ+wvgFMqPt1+GiaC2kZwFbeyD9bDF62Q==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

Code With Me 激活码

1MLIZRC8PBSEBKZ-eyJsaWNlbnNlSWQiOiIxTUxJWlJDOFBCU0VCS1oiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjpmYWxzZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wMTM2NTcwNTE1IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsInRyaWFsIjpmYWxzZSwiYWlBbGxvd2VkIjp0cnVlfQ==-E74NvEIq7TVw53KaIZ8Uz0yFAXSPp58KsoTuRjYQXbkiOf8lH/wn79NlQyeLbMqSkYeTUNseKbZFvxS/oNOwrbBOkFrcr2e38wxjlRGpfyOxs0JwMpCS3T1aWN+blS7SEZSCk3mLGkJGrLs3MhsVnEvDDHS+TCAm2vbiMSIOckM3NIJZI2SYGzI2hAblRlTFXBtVAP4AScGv3LDvfA10zSWaUbLB5gAhqjbfc2RTy5d3uGhAK6fYidkjGTguYufHVT7yiDDKz24qXjt1/ZZ9ZmgVwngD+mPbL+sSuo9EQ1Y+hc7CAMIP++wJi3TDGXdVtuR1kXpriycSERWl4FAcrA==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

RubyMine 激活码

3PZMNOLHULXID52-eyJsaWNlbnNlSWQiOiIzUFpNTk9MSFVMWElENTIiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlJNIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjpmYWxzZX1dLCJtZXRhZGF0YSI6IjAyMjAyNDA3MDJQU0FYMDAwMDA1WCIsImhhc2giOiIxMjM0NTY3OC8wODg1OTA3NTUiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwidHJpYWwiOmZhbHNlLCJhaUFsbG93ZWQiOnRydWV9-Gw4PbXUwvDcHyuCc3xGpt3BRpRRCxGCmOS4rQIJ/N0Aj0aHsf56ne8oMF593cz4KnDAgeacqGSi9+BrIXTEW52BOiogh5xukZSxHhd8FoKmuaBBYsM3ydaZPWhYL1rp65c0AZ5niIULRbb1hReiz1khjdkiGJqs9VHaR6/rF7HGmU1oagPhCw1u8+3nQM1oMiwl/2lxefZGAAk+/+7kRM/uZjg7TsF6a7UCvjYCAoCLxso58r45WWCIVU7Ofec2rFAIFjwflojDv3HjUdjw7ehSS529fJ4c7wqf6Z2o9o+G//po4eco5Sd5xw3dhocj6XX1Q7phz0VeL97UjwLQ8VQ==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

RustRover 激活码

TRY38TEUMV07NQH-eyJsaWNlbnNlSWQiOiJUUlkzOFRFVU1WMDdOUUgiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQUlIiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBTSSIsImZhbGxiYWNrRGF0ZSI6IjIwMjYtMDktMTQiLCJwYWlkVXBUbyI6IjIwMjYtMDktMTQiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUlIiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOmZhbHNlfV0sIm1ldGFkYXRhIjoiMDIyMDI0MDcwMlBTQVgwMDAwMDVYIiwiaGFzaCI6IjEyMzQ1Njc4LzAxNzYyNjY5OTAxIiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsInRyaWFsIjpmYWxzZSwiYWlBbGxvd2VkIjp0cnVlfQ==-MGoF9KNRZYTdjvzbKDtQ7JsVcUBuDej9qMukqhQHbF+byyY25F2H7YbW4lrMSOevKWRiehBjeSh6oJmWkrkECQvZJe17BhXKAP1QikuHar6pzDrIZy5gpPYVo6i509dtbDnqV8tt1rXvedkCkG5t3Jmxe2ZJGKKtPJSFZhiPPWOvRGbnL9GNydj9M3N2AaSVhRKidVXuVY26L5I01rRW+jDSlbD/h4e0CZZap5SHYOizQ+5nNBEef6lS0O8LJT1ov9NfHL7XzcGVzBDOFCRH6q1c9F+kMvkOtA7tNjUziTGaZ8tExlulPDg0skVyrHq24z6aSl8okqJufcKjrteK4w==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

Rider 激活码

0H5PC974JDMA7B0-eyJsaWNlbnNlSWQiOiIwSDVQQzk3NEpETUE3QjAiLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IlJEIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUERCIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOnRydWV9XSwibWV0YWRhdGEiOiIwMjIwMjQwNzAyUFNBWDAwMDAwNVgiLCJoYXNoIjoiMTIzNDU2NzgvMC0xODc3MTIwNzU2IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsInRyaWFsIjpmYWxzZSwiYWlBbGxvd2VkIjp0cnVlfQ==-YTG7LSYI79iFNfKNuHw85uQexHaQ1PMFTv5aBVxkrf2xcHmtX/oJZG9sE2bi32OVyMCnPfTV+SFkArsEw0jKNfGcCmjHIT3HctA+epp3POhEk2rN9DdmMnq0bEHXBJwAtsq47QqJLsBQVFKm4+JzjLXIdQTzQpJY9CIv1lAAWfCsw+hTEDduA8FRgnAhr7YMuJ7GNmZDWsgBiXY9zAHsJRLH2asLazoFJ5myio9k79Ga2leRzXVfm482DzhMJrPAxDlCPoN7me6lSYkVmVy5A2YjW4Zitl1HIQQoyu+Hd7WXcXgZsoFfrvx3Xghe9qw7JZaHzynldocUoW/H2rAzOQ==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

DataSpell 激活码

S94DZMOA2LL6XZM-eyJsaWNlbnNlSWQiOiJTOTREWk1PQTJMTDZYWk0iLCJsaWNlbnNlZU5hbWUiOiJtZW5vcmFoIHBhcmFwZXQiLCJsaWNlbnNlZVR5cGUiOiJQRVJTT05BTCIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IkRTIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUERCIiwiZmFsbGJhY2tEYXRlIjoiMjAyNi0wOS0xNCIsInBhaWRVcFRvIjoiMjAyNi0wOS0xNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDI2LTA5LTE0IiwicGFpZFVwVG8iOiIyMDI2LTA5LTE0IiwiZXh0ZW5kZWQiOnRydWV9XSwibWV0YWRhdGEiOiIwMjIwMjQwNzAyUFNBWDAwMDAwNVgiLCJoYXNoIjoiMTIzNDU2NzgvMC0xOTY5MjM0NDIiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwidHJpYWwiOmZhbHNlLCJhaUFsbG93ZWQiOnRydWV9-dsfBHCIV5tNybzlS6ROURFKl4UbxH2lenzpEkaIU9qA+PO552l4m2Oa8S5nr3z5TAGVl/cx/IcWTj2iBpqdnBApkQmAVqlULSdF/bm5MkcVSO/+COhQ9Z6s7YcSyDc06w/94slmhSkBM4f41U2rESv7xZqNzG097Zi06r8Y7+LGRbmgChUSWAk7FNRTdCoipWVjqpiBAQOLyLxAFk2NVGzhOdhJK9K6cC32i/a1zYoefEhqQRaUVYak39PLIpNILG8E7NZd3ij+3H5cPOE1f/+x007ZrzlrFBDcJisu0gKWqzFlk7mfNPNIfaJyCw8+1WXXTMzGCwk1nqhj2xcLmrQ==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABKaDfYJk51mtYwUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

END.

谷歌浏览器插件“此扩展程序不再受支持，因此已停用”的解决办法

Thu, 14 Aug 2025 23:14:16 +0800

第一步：升级谷歌浏览器到最新版本

设置->关于Chrome->检查升级，升级后重启浏览器

第二步：打开浏览器，将以下选项修改为Enabled

chrome://flags/#temporary-unexpire-flags-m137

修改后重启浏览器。

第三步：将以下选项都修改为Disabled

chrome://flags/#extension-manifest-v2-deprecation-warning
chrome://flags/#extension-manifest-v2-deprecation-disabled
chrome://flags/#extension-manifest-v2-deprecation-unsupported

修改后重启浏览器

第四步：将以下选项修改为Enabled

chrome://flags/#allow-legacy-mv2-extensions

修改后重启浏览器。

END.

Redis（十二）：Java客户端之Spring Data Redis

Wed, 13 Aug 2025 18:52:49 +0800

在上一篇文章《Redis（十一）：Java客户端之Jedis》中已经介绍了使用Jedis作为Redis客户端操作Redis的方法，实际上Redis的客户端有很多，Jedis只是其中之一，比较有名的还有Lettuce、Redisson，以及本篇文章将要介绍的Spring Data Redis。SpringBoot通过spring-boot-starter-data-redis模块提供了对Redis的完美支持，极大简化了Java开发者使用Redis的复杂度。本文将依次讲解如何在SpringBoot项目中集成盖组件，涵盖基础配置、数据操作、缓存实现等。

Spring Data Redis官方文档：https://docs.spring.io/spring-data/redis/reference/index.html

一、环境搭建

首先，我们需要redis环境，可以参考文章：《CentOS安装Redis》、《Redis（七）：多机部署之主从复制模式》、《Redis（八）：多机部署之Sentinel（哨兵）模式》、《Redis（九）：多机部署之Cluster（集群）模式》四篇文章分别搭建好主从复制模式、哨兵模式、集群模式三种模式的redis服务，有人问为什么不搭建standalone模式的Redis服务，实际上主从复制模式就是，只是多了几个从节点而已。部署好之后可以通过ps -aux | grep redis命令查询：

spring-boot-starter-data-redis组件是springboot官方的组件，引入类似组件要注意版本号应当与springboot版本号保持一致。上一篇文章《Java8升级的一点思考》说过了java8已经过时了，要使用java21，接下来就基于java21+最新版SpringBoot3.5.4搭建开发环境。

首先创建maven项目，并引入如下pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.kdyzm</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>3.5.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <scope>annotationProcessor</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>annotationProcessor</scope>
        </dependency>
    </dependencies>
</project>

然后启动类：

package cn.kdyzm;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

注意由于没有引入web组件，所以项目启动之后会退出，这是正常现象。

二、底层驱动

Spring Data Redis底层可以使用两种组件驱动连接Reids服务器：Jedis以及Lettuce，其中Lettuce是默认的组件，其依赖已经被自动引入，如果想替换成Jedis，则需要引入Jedis组件：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.5</version>
</dependency>

Jedis和Lettuce支持的操作不一样，但是总体来说Lettuce无论是功能多样性还是性能上均比Jedis强：

Supported Feature	Lettuce	Jedis
Standalone Connections	X	X
Master/Replica Connections	X
Redis Sentinel	Master Lookup, Sentinel Authentication, Replica Reads	Master Lookup
Redis Cluster	Cluster Connections, Cluster Node Connections, Replica Reads	Cluster Connections, Cluster Node Connections
Transport Channels	TCP, OS-native TCP (epoll, kqueue), Unix Domain Sockets	TCP
Connection Pooling	X (using `commons-pool2`)	X (using `commons-pool2`)
Other Connection Features	Singleton-connection sharing for non-blocking commands	Pipelining and Transactions mutually exclusive. Cannot use server/connection commands in pipeline/transactions.
SSL Support	X	X
Pub/Sub	X	X
Pipelining	X	X (Pipelining and Transactions mutually exclusive)
Transactions	X	X (Pipelining and Transactions mutually exclusive)
Datatype support	Key, String, List, Set, Sorted Set, Hash, Server, Stream, Scripting, Geo, HyperLogLog	Key, String, List, Set, Sorted Set, Hash, Server, Stream, Scripting, Geo, HyperLogLog
Reactive (non-blocking) API	X

三、连接模式

众所周知，Redis有四种运行方式：独立运行模式、主从复制模式、哨兵模式、集群模式，在spring-boot-stater-data-redis中这四种模式的连接需要做不同的配置，具体可以参考官方文档：https://docs.spring.io/spring-data/redis/reference/redis/connection-modes.html

以下四种模式均可以通过配置文件配置RedisConnectionFactory信息，但是需要显示声明RedisTemplate Bean对象。

1、独立运行模式

独立运行模式只需要连接一个Redis实例就可以了，新建RedisConfiguration类，其内容如下所示：

import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configurable
public class RedisConfiguration {

    public static final String HOST = "192.168.203.130";

    /**
     * Lettuce
     */
    @Bean
    public RedisConnectionFactory lettuceConnectionFactory() {
        return new LettuceConnectionFactory(new RedisStandaloneConfiguration(HOST, 6379));
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 必须设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }

//    /**
//     * Jedis
//     */
//    @Bean
//    public RedisConnectionFactory jedisConnectionFactory() {
//        return new JedisConnectionFactory(new RedisStandaloneConfiguration(HOST, 6379));
//    }
}

除了上述方法之外，还可以配置文件设置连接信息：

spring:
  data:
    redis:
      host: 192.168.203.130
      port: 6379
      database: 0

这样，只需要在代码里配置RedisTemplate信息就可以了，RedisConnectionFactory则会根据配置信息自动创建：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 必须设置序列化器
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new StringRedisSerializer());
    return template;
}

2、主从复制模式

主从复制模式的好处就是可以写主读从，但是没有哨兵加持的主从复制模式，无法实现自动故障转移。通过使用Lettuce相关功能，可以实现写主读从：

import io.lettuce.core.ReadFrom;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@Configuration
public class WriteToMasterReadFromReplicaConfiguration {

    public static final String HOST = "192.168.203.130";

	@Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 必须设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }
    
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
                .readFrom(ReadFrom.REPLICA_PREFERRED)//读操作优先考虑从节点，如果从节点不可用，从主节点读取
                .build();
        RedisStandaloneConfiguration serverConfig = new RedisStandaloneConfiguration(
                HOST, 6379
        );
        return new LettuceConnectionFactory(serverConfig, clientConfig);
    }
}

需要注意的是，不需要配置所有的节点，只需要配置主节点即可，从主节点可以自动发现其余从节点。代码中的readFrom方法只是设置了个读取的策略，并非用于设置从节点。

除了上述代码方法之外，还可以通过配置文件的方式配置RedisConnnectionFactory信息：

spring:
  data:
    redis:
      host: 192.168.203.130
      port: 6379
      database: 0
      lettuce:
        read-from: replica-preferred

3、哨兵模式

哨兵模式的配置非常简单，只需要提供master的名字以及所有哨兵节点的地址即可。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@Configuration
public class ReidsSentinelConfiguration1 {

    public static final String HOST = "192.168.203.130";

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 必须设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }
    
    /**
     * Lettuce
     */
    @Bean
    public RedisConnectionFactory lettuceConnectionFactory() {
        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel(HOST, 26379)
                .sentinel(HOST, 26380)
                .sentinel(HOST, 26381);
        return new LettuceConnectionFactory(sentinelConfig);
    }

//    /**
//     * Jedis
//     */
//    @Bean
//    public RedisConnectionFactory jedisConnectionFactory() {
//        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
//                .master("mymaster")
//                .sentinel(HOST, 26379)
//                .sentinel(HOST, 26380)
//                .sentinel(HOST, 26381);
//        return new JedisConnectionFactory(sentinelConfig);
//    }
}

当然也可以通过配置方式定义RedisConnectionFactory信息：

spring:
  data:
    redis:
      database: 0
      lettuce:
        read-from: replica-preferred
      sentinel:
        master: mymaster
        nodes:
          - 192.168.203.130:26379
          - 192.168.203.130:26380
          - 192.168.203.130:26381

4、集群模式

import org.assertj.core.util.Lists;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.List;

@Configuration
public class RedisClusterConfiguration1 {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 必须设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }

    @Bean
    public RedisConnectionFactory connectionFactory() {
        List<String> nodes = Lists.list(
                "192.168.203.130:30001",
                "192.168.203.130:30002",
                "192.168.203.130:30003",
                "192.168.203.130:30004",
                "192.168.203.130:30005",
                "192.168.203.130:30006",
                "192.168.203.130:30007",
                "192.168.203.130:30008",
                "192.168.203.130:30009",
                "192.168.203.130:30010",
                "192.168.203.130:30011"
        );
        return new LettuceConnectionFactory(
                new RedisClusterConfiguration(nodes));
    }

}

也可以通过配置文件方式定义RedisConnectionFactory信息：

spring:
  data:
    redis:
      lettuce:
        read-from: replica-preferred
      cluster:
        nodes:
          - 192.168.203.130:30001
          - 192.168.203.130:30002
          - 192.168.203.130:30003
          - 192.168.203.130:30004
          - 192.168.203.130:30005
          - 192.168.203.130:30006
          - 192.168.203.130:30007
          - 192.168.203.130:30008
          - 192.168.203.130:30009
          - 192.168.203.130:30010
          - 192.168.203.130:30011

注意集群配置不要和哨兵配置一起配置使用，如果一起配置使用，哨兵模式优先生效；另外集群模式配置中的数据库号设置实际上不会生效，因为集群模式只能使用db0。

四、使用RedisTemplate操作Redis

RedisTemplate是操作Reids最核心的类，操作Redis基本数据类型只需要记住这一个类就可以了。

1、配置RedisTemplate

从上面的案例中已经可以看得出RedisTemplate的配置方式了。如果在配置文件中配置了redis链接信息，比如如下单体Reids：

spring:
  data:
    redis:
      host: 192.168.203.130
      port: 6379
      database: 0

可以直接配置RedisTemplate实例Bean：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 必须设置序列化器
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new StringRedisSerializer());
    return template;
}

但是如果没有配置文件，需要完整的配置RedisConnectionFactory之后再配置RedisTemplaet：

import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configurable
public class RedisConfiguration {

    public static final String HOST = "192.168.203.130";

    /**
     * Lettuce
     */
    @Bean
    public RedisConnectionFactory lettuceConnectionFactory() {
        return new LettuceConnectionFactory(new RedisStandaloneConfiguration(HOST, 6379));
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 必须设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }

//    /**
//     * Jedis
//     */
//    @Bean
//    public RedisConnectionFactory jedisConnectionFactory() {
//        return new JedisConnectionFactory(new RedisStandaloneConfiguration(HOST, 6379));
//    }
}

2、配置序列化方式

我们写入Redis的时候发生了一次序列化操作，如何把我们的输入序列化之后传给Redis？序列化操作涉及到了Key的序列化以及Value的序列化，比较简单的就是都实用StringRedisSerializer：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 必须设置序列化器
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new StringRedisSerializer());
    return template;
}

当然还可以使用自定义的序列化方式，比如存储的值类型是Json格式，可以使用Json序列化工具。

如果使用第三方组件fastjson，先引入依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.58</version>
</dependency>

使用GenericFastJsonRedisSerializer类作为value的序列化工具：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 使用FastJson作为value的序列化工具
    GenericFastJsonRedisSerializer valueSerializer = new GenericFastJsonRedisSerializer();
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(valueSerializer);
    return template;
}

另外，对于Jackson，可以做如下配置：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.activateDefaultTyping(
            LaissezFaireSubTypeValidator.instance,
            ObjectMapper.DefaultTyping.NON_FINAL,
            JsonTypeInfo.As.WRAPPER_ARRAY);
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    objectMapper.registerModule(new JavaTimeModule());
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(
            objectMapper,
            Object.class);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(jackson2JsonRedisSerializer);
    return template;
}

3、使用RedisTemplate

首先看一个操作字符串的案例：

import lombok.extern.slf4j.Slf4j;
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.connection.RedisClusterNode;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Collection;

@Slf4j
@SpringBootTest
public class RedisConnectionTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void lettuceConnectionTest() {
        String result = (String) redisTemplate.opsForValue().get("lisi");
        log.info(result);
    }
}

使用RedisTemplate操作某种数据类型，需要先调用opsFor[X]方法获取Operation实例：

其中操作方法和获取的Operation对象对应如下：

方法	返回值	作用
redisTemplate.opsForValue()	`ValueOperations`	字符串操作对象
redisTemplate.opsForHash()	`HashOperations`	hash操作对象
redisTemplate.opsForList()	`ListOperations`	list操作对象
redisTemplate.opsForSet()	`SetOperations`	set操作对象
redisTemplate.opsForZSet()	`ZSetOperations`	sorted set操作对象
redisTemplate.opsForGeo()	`GeoOperations`	geo操作对象
redisTemplate.opsForHyperLogLog()	`HyperLogLogOperations`	hyperloglog操作对象
redisTemplate.opsForCluster()	`ClusterOperations`	集群操作对象

有些奇怪，为什么没有bitmap的操作对象？以为bitmap本身实际上是一个字符串，所以其操作合并到了ValueOperations中了：

另外，ClusterOperations 集成了一些集群管理命令，可以进行集群管理的一些操作，比如想查询某个节点的副本可以这样做：

Collection<RedisClusterNode> replicas = redisTemplate
        .opsForCluster()
        .getReplicas(new RedisClusterNode("192.168.203.130", 30001));

总之，拿到操作对象之后就可以操作Reids了，如果熟悉redis命令，则可以毫不费力的使用相关api：

更详细的api使用不再赘述。

五、消息发布/订阅

关于redis发布订阅的基本使用，可以参考我之前的文章：《Redis（二）：Redis发布订阅模式》，接下来看看在Spring Data Redis中如何实现发布订阅模式。官方文档可参考：https://docs.spring.io/spring-data/redis/reference/redis/pubsub.html

1、消息发布

消息发布最简单的方式就是使用RedisTemplate：

@Test
public void publishMessageTest() {
    redisTemplate.convertAndSend("channel_kdyzm", "Hello,World");
}

也可以使用RedisConnection对象发送消息：

@Test
public void publishMessageByConnection(){
    RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
    connection.publish(
            "channel_kdyzm".getBytes(StandardCharsets.UTF_8),
            "Hello,World".getBytes(StandardCharsets.UTF_8)
    );
}

2、消息接收

消息的接收稍微有些复杂，首先，我们定义一个类MessageReceiver用于接收消息：

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@AllArgsConstructor
public class MessageReceiver {

    public void receive(String message) {
        log.info("receive message:{}", message);
    }
}

然后配置一些Bean：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

@Configuration
public class PubSubConfig {

    /**
     * 创建自定义的接收消息的Bean
     */
    @Bean
    MessageReceiver listener() {
        return new MessageReceiver();
    }

    @Bean
    MessageListenerAdapter messageListenerAdapter(MessageReceiver listener) {
        //接收到消息的时候将会通过反射调用MessageReceiver对象的receive方法处理消息
        return new MessageListenerAdapter(listener, "receive");
    }

    @Bean
    RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory, MessageListenerAdapter listener) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        //监听channel_kdyzm channel
        container.addMessageListener(listener, ChannelTopic.of("channel_kdyzm"));
        return container;
    }
}

六、执行lua脚本

官方操作文档：https://docs.spring.io/spring-data/redis/reference/redis/scripting.html

比如我们有个lua脚本在resources资源目录下：

-- checkandset.lua
local current = redis.call('GET', KEYS[1])
if current == ARGV[1]
  then redis.call('SET', KEYS[1], ARGV[2])
  return true
end
return false

首先需要加载lua脚本：

@Bean
public RedisScript<Boolean> script() {
  ScriptSource scriptSource = new ResourceScriptSource(new ClassPathResource("META-INF/scripts/checkandset.lua"));
  return RedisScript.of(scriptSource, Boolean.class);
}

之后调用脚本：

public class Example {


  @Autowired
  private RedisTemplate<String, Object> redisTemplate;

  @Autowired
  RedisScript<Boolean> script;

  public boolean checkAndSet(String expectedValue, String newValue) {
    return redisTemplate.execute(script, List.of("key"), expectedValue, newValue);
  }
}

七、Reids Cache

Spring Data Reids组件除了提供了上述的直接操作Reids的功能外，还提供了封装好的缓存功能。官方文档地址：https://docs.spring.io/spring-data/redis/reference/redis/redis-cache.html

实际上SpringBoot要使用缓存功能，需要引入Spring Cache模块：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

但是我们已经引入了Spring Data Redis，就不需要再额外引入Spring Cache Starter了。

在成功集成了Spring Data Redis的情况下，只需要使用一个注解就可以开启缓存功能：@EnableCaching，开启缓存功能以后，会自动发现当前系统的缓存组件并启用。

@Cacheable

@Cacheable将方法的返回值缓存起来，后续相同参数的调用直接从缓存返回结果，避免重复执行方法体。该注解通常加到查询方法上，以减轻对数据库的查询压力。

该注解有两个非常重要的属性：

cacheNames：指定缓存存储的逻辑区域（即缓存组件的名称），类似于数据库中的“表名”或“命名空间”
key：定义缓存项在同一区域内的唯一标识（即缓存键），类似于数据库中的“主键”，一般需要Spel表达式定义改值。可以使用#p0、#a0、#root.args[0]表示第一个参数。需要注意的是，也可以使用#参数名指定参数，但是在编译的时候一定要加上-parameters，否则这种方法将会因为找不到key的值而报错，查看文章《【转载】JDK8新特性:将参数名带到字节码文件》了解更多。

所以，在一个查询接口中，可以这么设置缓存：

@Cacheable(cacheNames = "users",key = "#p0")
public String getUser(String id){
    log.info("查询用户信息");
    return "zhangsan";
}

如上代码中调用该方法之后，会向redis中插入一个key：users::1

::是默认的分隔符。

我认为该注解缺少一个功能，那就是没有办法设置缓存有效期。

@CachePut

该注解用于强制更新缓存，每次调用都会执行方法体并将结果存入缓存。该注解通常加到更新或者新增的方法上：

@CachePut(value = "users", key = "#user.id")
public User updateUser(User user) {
    return userRepository.save(user);
}

@CacheEvict

该注解用于删除缓存，通常加到删除操作的方法上：

@CacheEvict(value = "users", key = "#id")  // 清除单条
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}

八、其它

关于Redis的其它操作，Spring Data Redis还支持Streams、Transactions、Pipelining，由于用的比较少就不再介绍了，可以查看官方文档：

Streams：https://docs.spring.io/spring-data/redis/reference/redis/redis-streams.html
Transactions：https://docs.spring.io/spring-data/redis/reference/redis/transactions.html
Piplining：https://docs.spring.io/spring-data/redis/reference/redis/pipelining.html

END.

Java8升级的一点思考

Sun, 10 Aug 2025 13:12:37 +0800

Oracle 对 Java 8 的公开免费更新已于2019年终止，但是直到现在2025年，Java8还是非常流行，但是随着SpringBoot、SpringFramework等框架逐渐不再支持Java8环境下运行，升级Java8到新版本已经势在必行。

一、新版SpringBoot的要求

最近翻了翻SpringBoot的官方文档，突然发现SpringBoot已经发展到3.5.4了，而我还在用2.3.12，真的落后了好大一截。

https://spring.io/projects/spring-boot#learn

点开3.5.4文档：https://docs.spring.io/spring-boot/system-requirements.html

从官方文档可以看到，SpringBoot3.5.4需要Java17到最新版本的Java24之间的版本，不管是Java8还是Java11都已经不在支持的范围内。

二、新版SpringFramework的要求

新版SpringFramework已经到6.2.9版本，而我还在用5.2.15，同样落后了一个大版本号：https://spring.io/projects/spring-framework#learn

打开6.2.9版本的文档，可以看到该版本对Java版本的要求：https://docs.spring.io/spring-framework/reference/overview.html

同样的，新版本SpringFramework要求Java也至少得是Java17版本。

三、Java版本的选择

从SpringBoot以及SpringFramework的最新版本的要求来看，他们的运行环境至少得是Java17，那么我们应该升级到Java17吗？

打开Java官网看看：https://www.oracle.com/java/technologies/

可以看到，Java11、Java17、Java21是LTS（Long Term Support）版本，即长期支持版。Java11比较特殊，它虽然是LTS，但是一直被人诟病，最后成了一个Java8升级的“过渡版本”，而且SpringBoot以及SpringFramework都从Java17开始支持，所以Java11不做考虑了。考虑到Java17之上还有Java21也是LTS版本，那么毫无疑问，直接升级到Java21会是更好的选择。

Oracle JDK下载地址：https://www.oracle.com/java/technologies/downloads/#jdk21-windows

Open JDK下载地址： https://jdk.java.net/archive/

四、Java21新特性

写到这里我有些无语，因为Java21我也没用它开发过项目，我不知道它有啥新特性。。。。等抽空再整理整理吧。

END.

Redis（十一）：Java客户端之Jedis

Sat, 02 Aug 2025 22:39:29 +0800

Redis的Java客户端主要有Jedis和Lettuce，本篇文章将会讲解使用Jedis操作Reids。

Jedis 是一个同步的 Redis Java 客户端。如果需要一个更高级的 Java 客户端，同时支持异步和响应式连接，请使用 Lettuce 。Github地址：https://github.com/redis/jedis 。Jedis版本和Redis版本的对应关系图如下所示：

这里我使用了6.2.1版本的redis，所以需要选择>=5.0版本的jedis，这里选择5.1.5版本（具体参照maven中央仓库中的版本号）。

一、Hello，World

先看Hello，World级别的案例：下面建立和Reids Server的连接，并执行set命令：

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import redis.clients.jedis.UnifiedJedis;

/**
 * @author kdyzm
 * @date 2025/7/28
 */
@Slf4j
public class Jedis_demo {

    @Test
    public void hello() {
        UnifiedJedis jedis = new UnifiedJedis("redis://192.168.203.130:6379");
        jedis.set("result", "Hello,World");
        String result = jedis.get("result");
        log.info("get result={}", result);
        jedis.close();
    }
}

输出信息：

14:57:55.008 [main] INFO cn.kdyzm.jedis.demo.Jedis_demo - get result=Hello,World

可以看到使用jedis非常简单，它的命令和redis操作命令几乎一模一样。

二、连接到服务器

Redis部署有多种模式：单机版、主从复制模式、哨兵模式、集群模式，因此连接方式也有多种方式。

1、单机连接

很长时间以来，Jedis一直使用Jedis类作为客户端连接服务器，使用方法如下：

@Test
public void jedis_demo() {
    Jedis jedis = new Jedis(new HostAndPort("192.168.203.130",6379));
    jedis.set("result", "Hello,World");
    String result = jedis.get("result");
    log.info("get result={}", result);
    jedis.close();
}

在Jedis4.0的时候引入了新客户端：UnifiedJedis，统一了同步（阻塞）和异步（非阻塞）操作的API，支持更灵活的连接管理（如单连接或多连接模式）。

@Test
public void hello() {
    UnifiedJedis jedis = new UnifiedJedis("redis://192.168.203.130:6379");
    jedis.set("result", "Hello,World");
    String result = jedis.get("result");
    log.info("get result={}", result);
    jedis.close();
}

可以看到两者在使用上几乎没有区别，只是在初始化的时候有些不同。

当然就像数据库连接一样，我们不推荐直接使用jdbc创建Connection，而是通过Reids连接池来统一管理连接：

/**
 * 经典的jedis连接池
 */
@Test
public void jedis_pool_test() {
    JedisPool jedisPool = new JedisPool("192.168.203.130", 6379);
    Jedis jedis = jedisPool.getResource();
    jedis.set("result", "Hello,World");
    String result = jedis.get("result");
    log.info("get result={}", result);
    jedis.close();
}


/**
 * jedis4.0引入的新连接池
 */
@Test
public void jedis_pooled_test() {
    JedisPooled jedisPool = new JedisPooled("192.168.203.130", 6379);
    jedisPool.set("result", "Hello,World");
    String result = jedisPool.get("result");
    log.info("get result={}", result);
}

其中jedis4.0引入的JedisPooled连接池使用起来更简单一些，不需要手动释放资源，也不需要显式获取Reids客户端。

2、哨兵模式

jedis没有单独的为主从复制模式增加API，但是对哨兵模式的连接有专门的JedisSentinelPool类：

@Test
public void jedis_pool_sentinel() {
    JedisSentinelPool jedisSentinelPool = new JedisSentinelPool(
            "mymaster",
            new HashSet<>(Arrays.asList(
                    "192.168.203.130:26379",
                    "192.168.203.130:26380",
                    "192.168.203.130:26381"
            ))
    );
    try (Jedis resource = jedisSentinelPool.getResource()) {
        resource.set("result", "Hello,World");
        String result = resource.get("result");
        log.info("get result={}", result);
    }
}

运行结果如下：

15:54:37.102 [main] INFO redis.clients.jedis.JedisSentinelPool - Trying to find master from available Sentinels...
15:54:37.102 [main] DEBUG redis.clients.jedis.JedisSentinelPool - Connecting to Sentinel 192.168.203.130:26380
15:54:37.143 [main] DEBUG redis.clients.jedis.JedisSentinelPool - Found Redis master at 192.168.203.130:6379
15:54:37.143 [main] INFO redis.clients.jedis.JedisSentinelPool - Redis master running at 192.168.203.130:6379, starting Sentinel listeners...
15:54:37.147 [main] INFO redis.clients.jedis.JedisSentinelPool - Created JedisSentinelPool to master at 192.168.203.130:6379
15:54:37.151 [main] INFO cn.kdyzm.jedis.demo.Jedis_demo - get result=Hello,World

需要注意的是，sentinel集群中的配置一定不要写错了：

sentinel monitor mymaster 192.168.203.130 6379 2 #这里的ip地址一定不要写成了127.0.0.1

3、集群模式

jedis中使用JedisCluster 连接Redis集群模式：

@Test
public void jedis_cluster() {
    JedisCluster jedisCluster = new JedisCluster(
            new HostAndPort("192.168.203.130", 30001)
    );
    jedisCluster.set("result", "Hello,World");
    String result = jedisCluster.get("result");
    log.info("get result={}", result);
}

集群模式的连接也很简单，只需要传入集群任意节点的ip和端口号即可。

需要注意的是，在创建集群的时候ip地址一定不要写错了：

./redis-cli --cluster create 192.168.203.130:30001 192.168.203.130:30002 192.168.203.130:30003 192.168.203.130:30004 192.168.203.130:30005 192.168.203.130:30006 192.168.203.130:30007 192.168.203.130:30008 192.168.203.130:30009 192.168.203.130:30010 192.168.203.130:30011 --cluster-replicas 1

如果写错了的话会连接不上集群，修复集群中每个端口号会比较麻烦。我的修复方案比较暴力：

杀掉集群中全部reids进程，删除node配置文件，之后全部重新启动；
在集群中任意节点上使用cluster meet命令将节点一个一个加入集群
使用./reids-cli --cluster check命令检查集群状态，会发现此时cluster集群状态异常，不是所有的槽都分配了：使用./redis-cli --cluster fix命令修复集群问题。

三、常用API

jedis的api设计和redis命令格式高度一致，所以基本上会使用redis命令，就知道怎么使用jedis了。

1、string类型操作

package cn.kdyzm.jedis.demo;

import org.junit.Test;
import redis.clients.jedis.JedisPooled;

import java.util.List;

import static org.junit.Assert.*;

public class StringDemo {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);

    @Test
    public void testSetAndGetOperation() {
        // 设置键值
        String setResult = jedis.set("testKey", "testValue");
        assertEquals("OK", setResult);
        System.out.println("SET operation successful");

        // 获取值
        String value = jedis.get("testKey");
        assertEquals("testValue", value);
        System.out.println("GET operation successful - Value: " + value);
    }

    @Test
    public void testSetexOperation() {
        // 设置带过期时间的键值
        String setexResult = jedis.setex("tempKey", 10, "tempValue");
        assertEquals("OK", setexResult);
        System.out.println("SETEX operation successful");

        // 验证TTL
        long ttl = jedis.ttl("tempKey");
        assertTrue(ttl > 0 && ttl <= 10);
        System.out.println("TTL verification successful - Remaining: " + ttl + " seconds");
    }

    @Test
    public void testIncrAndDecrOperations() {
        // 重置计数器
        jedis.set("counter", "0");

        // 测试递增
        long incrResult = jedis.incr("counter");
        assertEquals(1, incrResult);
        System.out.println("INCR operation successful - New value: " + incrResult);

        // 测试递减
        long decrResult = jedis.decr("counter");
        assertEquals(0, decrResult);
        System.out.println("DECR operation successful - New value: " + decrResult);
    }

    @Test
    public void testAppendOperation() {
        // 设置初始值
        jedis.set("appendKey", "initial");

        // 测试追加
        long appendLength = jedis.append("appendKey", "_appended");
        assertTrue(appendLength > 7); // "initial".length() == 7
        System.out.println("APPEND operation successful - New length: " + appendLength);

        // 验证追加结果
        String appendedValue = jedis.get("appendKey");
        assertEquals("initial_appended", appendedValue);
        System.out.println("Appended value verification successful: " + appendedValue);
    }

    @Test
    public void testStrlenOperation() {
        // 设置测试值
        jedis.set("lengthKey", "123456789");

        // 测试字符串长度
        long length = jedis.strlen("lengthKey");
        assertEquals(9, length);
        System.out.println("STRLEN operation successful - Length: " + length);
    }

    @Test
    public void testMsetAndMgetOperations() {
        // 测试批量设置
        String msetResult = jedis.mset("multi1", "value1", "multi2", "value2");
        assertEquals("OK", msetResult);
        System.out.println("MSET operation successful");

        // 测试批量获取
        List<String> values = jedis.mget("multi1", "multi2");
        assertNotNull(values);
        assertEquals(2, values.size());
        assertEquals("value1", values.get(0));
        assertEquals("value2", values.get(1));
        System.out.println("MGET operation successful - Values: " + values);
    }
}

2、hash类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Test;
import redis.clients.jedis.JedisPooled;

import java.util.Map;
import java.util.Set;
import java.util.List;

import static org.junit.Assert.*;

public class RedisHashOperationsTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String HASH_KEY = "user:1";

    @Test
    public void testHsetAndHget() {
        // 设置字段值
        long hsetResult1 = jedis.hset(HASH_KEY, "name", "Alice");
        long hsetResult2 = jedis.hset(HASH_KEY, "age", "30");
        assertTrue(hsetResult1 >= 0);
        assertTrue(hsetResult2 >= 0);
        System.out.println("HSET operations successful");

        // 获取字段值
        String name = jedis.hget(HASH_KEY, "name");
        assertEquals("Alice", name);
        System.out.println("HGET operation successful - Name: " + name);
    }

    @Test
    public void testHgetAll() {
        // 准备测试数据
        jedis.hset(HASH_KEY, "name", "Alice");
        jedis.hset(HASH_KEY, "age", "30");

        // 获取所有字段和值
        Map<String, String> user = jedis.hgetAll(HASH_KEY);
        assertNotNull(user);
        assertEquals(2, user.size());
        assertEquals("Alice", user.get("name"));
        assertEquals("30", user.get("age"));
        System.out.println("HGETALL operation successful - User data: " + user);
    }

    @Test
    public void testHdel() {
        // 准备测试数据
        jedis.hset(HASH_KEY, "age", "30");

        // 删除字段
        long deleted = jedis.hdel(HASH_KEY, "age");
        assertEquals(1, deleted);
        System.out.println("HDEL operation successful - Fields deleted: " + deleted);

        // 验证字段已删除
        boolean exists = jedis.hexists(HASH_KEY, "age");
        assertFalse(exists);
        System.out.println("Field deletion verification successful");
    }

    @Test
    public void testHexists() {
        // 准备测试数据
        jedis.hset(HASH_KEY, "name", "Alice");

        // 判断字段是否存在
        boolean exists = jedis.hexists(HASH_KEY, "name");
        assertTrue(exists);
        System.out.println("HEXISTS operation successful - Field exists: " + exists);

        // 验证不存在的字段
        boolean notExists = jedis.hexists(HASH_KEY, "nonexistent");
        assertFalse(notExists);
        System.out.println("HEXISTS operation successful - Nonexistent field check passed");
    }

    @Test
    public void testHkeys() {
        // 准备测试数据
        jedis.hset(HASH_KEY, "name", "Alice");
        jedis.hset(HASH_KEY, "age", "30");
        jedis.hset(HASH_KEY, "email", "alice@example.com");

        // 获取所有字段名
        Set<String> fields = jedis.hkeys(HASH_KEY);
        assertNotNull(fields);
        assertEquals(3, fields.size());
        assertTrue(fields.contains("name"));
        assertTrue(fields.contains("age"));
        assertTrue(fields.contains("email"));
        System.out.println("HKEYS operation successful - Fields: " + fields);
    }

    @Test
    public void testHvals() {
        // 准备测试数据
        jedis.hset(HASH_KEY, "name", "Alice");
        jedis.hset(HASH_KEY, "age", "30");

        // 获取所有值
        List<String> vals = jedis.hvals(HASH_KEY);
        assertNotNull(vals);
        assertEquals(2, vals.size());
        assertTrue(vals.contains("Alice"));
        assertTrue(vals.contains("30"));
        System.out.println("HVALS operation successful - Values: " + vals);
    }

    @Test
    public void testHincrBy() {
        // 准备测试数据
        jedis.hset(HASH_KEY, "age", "30");

        // 递增字段值
        long newAge = jedis.hincrBy(HASH_KEY, "age", 1);
        assertEquals(31, newAge);
        System.out.println("HINCRBY operation successful - New age: " + newAge);

        // 验证新值
        String updatedAge = jedis.hget(HASH_KEY, "age");
        assertEquals("31", updatedAge);
        System.out.println("Incremented value verification successful");
    }

    @After
    public void cleanup() {
        // 清理测试数据
        jedis.del(HASH_KEY);
        System.out.println("Test data cleaned up");
    }
}

3、list类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Test;
import redis.clients.jedis.JedisPooled;
import java.util.List;
import static org.junit.Assert.*;

public class RedisListOperationsTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String LIST_KEY = "testList";

    @Test
    public void testLpushAndRpush() {
        // 从左边插入元素
        long lpushResult = jedis.lpush(LIST_KEY, "item1", "item2");
        assertEquals(2, lpushResult);
        System.out.println("LPUSH operation successful - Items added: " + lpushResult);

        // 从右边插入元素
        long rpushResult = jedis.rpush(LIST_KEY, "item3");
        assertEquals(3, rpushResult);
        System.out.println("RPUSH operation successful - Items count: " + rpushResult);
    }

    @Test
    public void testLlen() {
        // 准备测试数据
        jedis.lpush(LIST_KEY, "item1", "item2", "item3");

        // 获取列表长度
        long length = jedis.llen(LIST_KEY);
        assertEquals(3, length);
        System.out.println("LLEN operation successful - List length: " + length);
    }

    @Test
    public void testLrange() {
        // 准备测试数据
        jedis.rpush(LIST_KEY, "item1", "item2", "item3");

        // 获取列表元素
        List<String> items = jedis.lrange(LIST_KEY, 0, -1);
        assertNotNull(items);
        assertEquals(3, items.size());
        assertEquals("item1", items.get(0));
        assertEquals("item2", items.get(1));
        assertEquals("item3", items.get(2));
        System.out.println("LRANGE operation successful - All items: " + items);
    }

    @Test
    public void testLpopAndRpop() {
        // 准备测试数据
        jedis.rpush(LIST_KEY, "item1", "item2", "item3");

        // 弹出左边元素
        String leftItem = jedis.lpop(LIST_KEY);
        assertEquals("item1", leftItem);
        System.out.println("LPOP operation successful - Popped item: " + leftItem);

        // 弹出右边元素
        String rightItem = jedis.rpop(LIST_KEY);
        assertEquals("item3", rightItem);
        System.out.println("RPOP operation successful - Popped item: " + rightItem);

        // 验证剩余元素
        long remaining = jedis.llen(LIST_KEY);
        assertEquals(1, remaining);
        System.out.println("Remaining items count: " + remaining);
    }

    @Test
    public void testLindex() {
        // 准备测试数据
        jedis.rpush(LIST_KEY, "item1", "item2", "item3");

        // 根据索引获取元素
        String item = jedis.lindex(LIST_KEY, 1);
        assertEquals("item2", item);
        System.out.println("LINDEX operation successful - Item at index 1: " + item);

        // 测试不存在的索引
        String nonExistItem = jedis.lindex(LIST_KEY, 5);
        assertNull(nonExistItem);
        System.out.println("LINDEX operation successful - Non-existent index returns null");
    }

    @Test
    public void testLtrim() {
        // 准备测试数据
        jedis.rpush(LIST_KEY, "item1", "item2", "item3", "item4");

        // 修剪列表
        String ltrimResult = jedis.ltrim(LIST_KEY, 0, 1);
        assertEquals("OK", ltrimResult);
        System.out.println("LTRIM operation successful");

        // 验证修剪结果
        List<String> items = jedis.lrange(LIST_KEY, 0, -1);
        assertEquals(2, items.size());
        assertEquals("item1", items.get(0));
        assertEquals("item2", items.get(1));
        System.out.println("List after trim: " + items);
    }

    @After
    public void cleanup() {
        // 清理测试数据
        jedis.del(LIST_KEY);
        System.out.println("Test data cleaned up");
    }
}

4、set类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.JedisPooled;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import static org.junit.Assert.*;

public class RedisSetOperationsTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String SET_KEY = "testSet";
    private static final String SET1_KEY = "set1";
    private static final String SET2_KEY = "set2";

    @Before
    public void setUp() {
        // 清空测试用key
        jedis.del(SET_KEY, SET1_KEY, SET2_KEY);
    }

    @After
    public void tearDown() {
        // 清理测试数据
        jedis.del(SET_KEY, SET1_KEY, SET2_KEY);
        System.out.println("Test data cleaned up");
    }

    @Test
    public void testSaddAndSmembers() {
        // 添加元素
        long added = jedis.sadd(SET_KEY, "member1", "member2");
        assertEquals(2, added);
        System.out.println("SADD operation successful - Members added: " + added);

        // 获取所有成员
        Set<String> members = jedis.smembers(SET_KEY);
        assertNotNull(members);
        assertEquals(2, members.size());
        assertTrue(members.contains("member1"));
        assertTrue(members.contains("member2"));
        System.out.println("SMEMBERS operation successful - Members: " + members);
    }

    @Test
    public void testSismember() {
        // 准备测试数据
        jedis.sadd(SET_KEY, "member1", "member2");

        // 判断是否是成员
        boolean isMember = jedis.sismember(SET_KEY, "member1");
        assertTrue(isMember);
        System.out.println("SISMEMBER operation successful - 'member1' exists: " + isMember);

        // 测试不存在的成员
        boolean notMember = jedis.sismember(SET_KEY, "nonMember");
        assertFalse(notMember);
        System.out.println("SISMEMBER operation successful - 'nonMember' does not exist");
    }

    @Test
    public void testSrem() {
        // 准备测试数据
        jedis.sadd(SET_KEY, "member1", "member2", "member3");

        // 移除成员
        long removed = jedis.srem(SET_KEY, "member1", "member3");
        assertEquals(2, removed);
        System.out.println("SREM operation successful - Members removed: " + removed);

        // 验证移除结果
        Set<String> remaining = jedis.smembers(SET_KEY);
        assertEquals(1, remaining.size());
        assertTrue(remaining.contains("member2"));
        System.out.println("Remaining members: " + remaining);
    }

    @Test
    public void testScard() {
        // 准备测试数据
        jedis.sadd(SET_KEY, "member1", "member2", "member3", "member4");

        // 获取集合大小
        long size = jedis.scard(SET_KEY);
        assertEquals(4, size);
        System.out.println("SCARD operation successful - Set size: " + size);
    }

    @Test
    public void testSrandmember() {
        // 准备测试数据
        jedis.sadd(SET_KEY, "member1", "member2", "member3");

        // 随机获取一个成员
        String randomMember = jedis.srandmember(SET_KEY);
        assertNotNull(randomMember);
        assertTrue(randomMember.startsWith("member"));
        System.out.println("SRANDMEMBER operation successful - Random member: " + randomMember);
    }

    @Test
    public void testSetOperations() {
        // 准备测试数据
        jedis.sadd(SET1_KEY, "a", "b", "c");
        jedis.sadd(SET2_KEY, "b", "c", "d");

        // 交集
        Set<String> intersection = jedis.sinter(SET1_KEY, SET2_KEY);
        assertNotNull(intersection);
        assertEquals(2, intersection.size());
        assertTrue(intersection.contains("b"));
        assertTrue(intersection.contains("c"));
        System.out.println("SINTER operation successful - Intersection: " + intersection);

        // 并集
        Set<String> union = jedis.sunion(SET1_KEY, SET2_KEY);
        assertNotNull(union);
        assertEquals(4, union.size());
        assertTrue(union.containsAll(new HashSet<>(Arrays.asList("a", "b", "c", "d"))));
        System.out.println("SUNION operation successful - Union: " + union);

        // 差集
        Set<String> difference = jedis.sdiff(SET1_KEY, SET2_KEY);
        assertNotNull(difference);
        assertEquals(1, difference.size());
        assertTrue(difference.contains("a"));
        System.out.println("SDIFF operation successful - Difference: " + difference);
    }
}

5、zset类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.JedisPooled;
import redis.clients.jedis.resps.Tuple;

import java.util.List;

import static org.junit.Assert.*;

public class RedisZSetOperationsTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String ZSET_KEY = "testZSet";

    @Before
    public void setUp() {
        // 清空测试用key
        jedis.del(ZSET_KEY);
    }

    @After
    public void tearDown() {
        // 清理测试数据
        jedis.del(ZSET_KEY);
        System.out.println("Test data cleaned up");
    }

    @Test
    public void testZaddAndZscore() {
        // 添加成员
        long added1 = jedis.zadd(ZSET_KEY, 1.0, "member1");
        assertEquals(1, added1);

        long added2 = jedis.zadd(ZSET_KEY, 2.0, "member2");
        assertEquals(1, added2);

        System.out.println("ZADD operations successful");

        // 获取成员分数
        Double score = jedis.zscore(ZSET_KEY, "member1");
        assertEquals(1.0, score, 0.001);
        System.out.println("ZSCORE operation successful - Score: " + score);
    }

    @Test
    public void testZrankAndZrevrank() {
        // 准备测试数据
        jedis.zadd(ZSET_KEY, 1.0, "member1");
        jedis.zadd(ZSET_KEY, 2.0, "member2");
        jedis.zadd(ZSET_KEY, 3.0, "member3");

        // 获取排名(从小到大)
        long rank = jedis.zrank(ZSET_KEY, "member1");
        assertEquals(0, rank);
        System.out.println("ZRANK operation successful - Rank: " + rank);

        // 获取排名(从大到小)
        long revRank = jedis.zrevrank(ZSET_KEY, "member1");
        assertEquals(2, revRank);
        System.out.println("ZREVRANK operation successful - Reverse rank: " + revRank);
    }

    @Test
    public void testZrangeAndZrevrange() {
        // 准备测试数据
        jedis.zadd(ZSET_KEY, 1.0, "member1");
        jedis.zadd(ZSET_KEY, 2.0, "member2");
        jedis.zadd(ZSET_KEY, 3.0, "member3");

        // 获取范围内的成员(从小到大)
        List<String> members = jedis.zrange(ZSET_KEY, 0, -1);
        assertArrayEquals(new String[]{"member1", "member2", "member3"},
                members.toArray(new String[0]));
        System.out.println("ZRANGE operation successful - Members: " + members);

        // 获取范围内的成员(从大到小)
        List<String> revMembers = jedis.zrevrange(ZSET_KEY, 0, -1);
        assertArrayEquals(new String[]{"member3", "member2", "member1"},
                revMembers.toArray(new String[0]));
        System.out.println("ZREVRANGE operation successful - Reverse members: " + revMembers);
    }

    @Test
    public void testZrangeWithScores() {
        // 准备测试数据
        jedis.zadd(ZSET_KEY, 1.0, "member1");
        jedis.zadd(ZSET_KEY, 2.0, "member2");

        // 获取范围内的成员(带分数)
        List<Tuple> tuples = jedis.zrangeWithScores(ZSET_KEY, 0, -1);
        assertEquals(2, tuples.size());

        for (Tuple tuple : tuples) {
            String element = tuple.getElement();
            double score = tuple.getScore();
            System.out.println("Member: " + element + ", Score: " + score);

            if (element.equals("member1")) {
                assertEquals(1.0, score, 0.001);
            } else if (element.equals("member2")) {
                assertEquals(2.0, score, 0.001);
            }
        }
        System.out.println("ZRANGE WITHSCORES operation successful");
    }

    @Test
    public void testZrangeByScore() {
        // 准备测试数据
        jedis.zadd(ZSET_KEY, 1.0, "member1");
        jedis.zadd(ZSET_KEY, 2.0, "member2");
        jedis.zadd(ZSET_KEY, 3.0, "member3");

        // 根据分数范围获取成员
        List<String> byScore = jedis.zrangeByScore(ZSET_KEY, 1.0, 2.0);
        assertEquals(2, byScore.size());
        assertTrue(byScore.contains("member1"));
        assertTrue(byScore.contains("member2"));
        System.out.println("ZRANGEBYSCORE operation successful - Members: " + byScore);
    }

    @Test
    public void testZrem() {
        // 准备测试数据
        jedis.zadd(ZSET_KEY, 1.0, "member1");
        jedis.zadd(ZSET_KEY, 2.0, "member2");

        // 移除成员
        long removed = jedis.zrem(ZSET_KEY, "member1");
        assertEquals(1, removed);
        System.out.println("ZREM operation successful - Members removed: " + removed);

        // 验证移除结果
        Double score = jedis.zscore(ZSET_KEY, "member1");
        assertNull(score);
        System.out.println("Member removal verification successful");
    }

    @Test
    public void testZcard() {
        // 准备测试数据
        jedis.zadd(ZSET_KEY, 1.0, "member1");
        jedis.zadd(ZSET_KEY, 2.0, "member2");
        jedis.zadd(ZSET_KEY, 3.0, "member3");

        // 获取集合大小
        long size = jedis.zcard(ZSET_KEY);
        assertEquals(3, size);
        System.out.println("ZCARD operation successful - Set size: " + size);
    }
}

6、bitmap类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.JedisPooled;
import redis.clients.jedis.args.BitOP;

import static org.junit.Assert.*;

public class RedisBitmapOperationsTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String BITMAP_KEY = "testBitmap";
    private static final String BITMAP1_KEY = "bitmap1";
    private static final String BITMAP2_KEY = "bitmap2";
    private static final String RESULT_KEY = "bitResult";

    @Before
    public void setUp() {
        // 清空测试用key
        jedis.del(BITMAP_KEY, BITMAP1_KEY, BITMAP2_KEY, RESULT_KEY);
    }

    @After
    public void tearDown() {
        // 清理测试数据
        jedis.del(BITMAP_KEY, BITMAP1_KEY, BITMAP2_KEY, RESULT_KEY);
        System.out.println("Test data cleaned up");
    }

    @Test
    public void testSetbitAndGetbit() {
        // 设置位
        boolean prevBit1 = jedis.setbit(BITMAP_KEY, 0, true);
        assertFalse(prevBit1); // 之前该位应该是0
        System.out.println("SETBIT operation successful - Set bit 0 to 1");

        boolean prevBit2 = jedis.setbit(BITMAP_KEY, 1, false);
        assertFalse(prevBit2); // 之前该位应该是0
        System.out.println("SETBIT operation successful - Set bit 1 to 0");

        // 获取位
        boolean bit0 = jedis.getbit(BITMAP_KEY, 0);
        assertTrue(bit0);
        System.out.println("GETBIT operation successful - Bit 0: " + bit0);

        boolean bit1 = jedis.getbit(BITMAP_KEY, 1);
        assertFalse(bit1);
        System.out.println("GETBIT operation successful - Bit 1: " + bit1);

        // 测试未设置的位
        boolean bit100 = jedis.getbit(BITMAP_KEY, 100);
        assertFalse(bit100);
        System.out.println("GETBIT operation successful - Unset bit 100: " + bit100);
    }

    @Test
    public void testBitcount() {
        // 准备测试数据
        jedis.setbit(BITMAP_KEY, 0, true);
        jedis.setbit(BITMAP_KEY, 1, false);
        jedis.setbit(BITMAP_KEY, 2, true);
        jedis.setbit(BITMAP_KEY, 3, true);
        jedis.setbit(BITMAP_KEY, 4, false);

        // 统计设置为1的位数
        long count = jedis.bitcount(BITMAP_KEY);
        assertEquals(3, count);
        System.out.println("BITCOUNT operation successful - Count: " + count);

        // 测试指定范围内的bitcount
        long rangeCount = jedis.bitcount(BITMAP_KEY, 0, 1); // 前两个字节
        assertEquals(3, rangeCount); 
        System.out.println("BITCOUNT with range operation successful - Count: " + rangeCount);
    }

    @Test
    public void testBitop() {
        // 准备测试数据
        jedis.setbit(BITMAP1_KEY, 0, true);
        jedis.setbit(BITMAP1_KEY, 1, true);
        jedis.setbit(BITMAP1_KEY, 2, false);

        jedis.setbit(BITMAP2_KEY, 0, true);
        jedis.setbit(BITMAP2_KEY, 1, false);
        jedis.setbit(BITMAP2_KEY, 2, true);

        // 位运算 AND
        long resultLength = jedis.bitop(BitOP.AND, RESULT_KEY, BITMAP1_KEY, BITMAP2_KEY);
        assertTrue(resultLength > 0);
        System.out.println("BITOP AND operation successful - Result length: " + resultLength);

        // 验证结果
        assertTrue(jedis.getbit(RESULT_KEY, 0));  // 1 AND 1 = 1
        assertFalse(jedis.getbit(RESULT_KEY, 1)); // 1 AND 0 = 0
        assertFalse(jedis.getbit(RESULT_KEY, 2)); // 0 AND 1 = 0
        System.out.println("BITOP AND verification successful");

        // 位运算 OR
        resultLength = jedis.bitop(BitOP.OR, RESULT_KEY, BITMAP1_KEY, BITMAP2_KEY);
        assertTrue(resultLength > 0);
        System.out.println("BITOP OR operation successful - Result length: " + resultLength);

        // 验证结果
        assertTrue(jedis.getbit(RESULT_KEY, 0));  // 1 OR 1 = 1
        assertTrue(jedis.getbit(RESULT_KEY, 1));  // 1 OR 0 = 1
        assertTrue(jedis.getbit(RESULT_KEY, 2));  // 0 OR 1 = 1
        System.out.println("BITOP OR verification successful");

        // 位运算 XOR
        resultLength = jedis.bitop(BitOP.XOR, RESULT_KEY, BITMAP1_KEY, BITMAP2_KEY);
        assertTrue(resultLength > 0);
        System.out.println("BITOP XOR operation successful - Result length: " + resultLength);

        // 验证结果
        assertFalse(jedis.getbit(RESULT_KEY, 0)); // 1 XOR 1 = 0
        assertTrue(jedis.getbit(RESULT_KEY, 1));  // 1 XOR 0 = 1
        assertTrue(jedis.getbit(RESULT_KEY, 2));  // 0 XOR 1 = 1
        System.out.println("BITOP XOR verification successful");

        // 位运算 NOT (只需要一个源key)
        resultLength = jedis.bitop(BitOP.NOT, RESULT_KEY, BITMAP1_KEY);
        assertTrue(resultLength > 0);
        System.out.println("BITOP NOT operation successful - Result length: " + resultLength);

        // 验证结果
        assertFalse(jedis.getbit(RESULT_KEY, 0)); // NOT 1 = 0
        assertFalse(jedis.getbit(RESULT_KEY, 1)); // NOT 1 = 0
        assertTrue(jedis.getbit(RESULT_KEY, 2));  // NOT 0 = 1
        System.out.println("BITOP NOT verification successful");
    }
}

7、HyperLogLog类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.JedisPooled;
import static org.junit.Assert.*;

public class RedisHyperLogLogTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String HLL_KEY = "testHLL";
    private static final String HLL2_KEY = "testHLL2";
    private static final String MERGED_KEY = "mergedHLL";

    @Before
    public void setUp() {
        // 清空测试用key
        jedis.del(HLL_KEY, HLL2_KEY, MERGED_KEY);
    }

    @After
    public void tearDown() {
        // 清理测试数据
        jedis.del(HLL_KEY, HLL2_KEY, MERGED_KEY);
        System.out.println("Test data cleaned up");
    }

    @Test
    public void testPfaddAndPfcount() {
        // 添加元素
        long added = jedis.pfadd(HLL_KEY, "item1", "item2", "item3");
        assertEquals(1, added);
        System.out.println("PFADD operation successful - Elements added");

        // 获取基数估计
        long count = jedis.pfcount(HLL_KEY);
        assertEquals(3, count);
        System.out.println("PFCOUNT operation successful - Estimated count: " + count);

        // 添加重复元素
        long dupAdded = jedis.pfadd(HLL_KEY, "item1", "item2");
        assertEquals(0, dupAdded);
        System.out.println("PFADD with duplicates - No new elements added");

        // 验证基数不变
        long sameCount = jedis.pfcount(HLL_KEY);
        assertEquals(3, sameCount);
        System.out.println("PFCOUNT after duplicates - Same count: " + sameCount);
    }

    @Test
    public void testPfmerge() {
        // 准备测试数据
        jedis.pfadd(HLL_KEY, "item1", "item2", "item3");
        jedis.pfadd(HLL2_KEY, "item3", "item4", "item5");

        // 合并多个HLL
        String mergeResult = jedis.pfmerge(MERGED_KEY, HLL_KEY, HLL2_KEY);
        assertEquals("OK", mergeResult);
        System.out.println("PFMERGE operation successful");

        // 获取合并后的基数估计
        long mergedCount = jedis.pfcount(MERGED_KEY);
        assertTrue(mergedCount >= 5 && mergedCount <= 6); // HyperLogLog有约0.81%误差
        System.out.println("PFCOUNT after merge - Estimated count: " + mergedCount);

        // 验证原始HLL不变
        long originalCount = jedis.pfcount(HLL_KEY);
        assertEquals(3, originalCount);
        System.out.println("Original HLL count unchanged: " + originalCount);
    }

    @Test
    public void testEmptyHLL() {
        // 测试空HLL
        long emptyCount = jedis.pfcount(HLL_KEY);
        assertEquals(0, emptyCount);
        System.out.println("PFCOUNT on empty HLL returns 0");

        // 添加空元素
        long emptyAdd = jedis.pfadd(HLL_KEY);
        assertEquals(1, emptyAdd);
        System.out.println("PFADD with no elements returns 1");
    }

    @Test
    public void testHLLAccuracy() {
        // 测试HLL的基数估计准确性
        int testSize = 10000;
        String[] elements = new String[testSize];

        // 生成10000个唯一元素
        for (int i = 0; i < testSize; i++) {
            elements[i] = "element-" + i;
        }

        // 添加元素到HLL
        jedis.pfadd(HLL_KEY, elements);

        // 获取基数估计
        long estimatedCount = jedis.pfcount(HLL_KEY);
        System.out.println("Actual count: " + testSize + ", Estimated count: " + estimatedCount);

        // 计算误差率 (HLL标准误差约0.81%)
        double errorRate = Math.abs(estimatedCount - testSize) * 100.0 / testSize;
        System.out.printf("Error rate: %.2f%%\n", errorRate);

        // 验证误差在合理范围内
        assertTrue(errorRate < 2.0); // 放宽到2%以应对测试波动
    }
}

8、GEO类型操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.*;
import redis.clients.jedis.args.GeoUnit;
import redis.clients.jedis.params.GeoRadiusParam;
import redis.clients.jedis.resps.GeoRadiusResponse;

import java.util.List;

import static org.junit.Assert.*;

public class RedisGeoOperationsTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private JedisPooled jedis = new JedisPooled(HOST, PORT);
    private static final String GEO_KEY = "cities";

    // 城市坐标常量
    private static final double BEIJING_LON = 116.405285;
    private static final double BEIJING_LAT = 39.904989;
    private static final double SHANGHAI_LON = 121.474490;
    private static final double SHANGHAI_LAT = 31.230416;
    private static final double GUANGZHOU_LON = 113.264385;
    private static final double GUANGZHOU_LAT = 23.129112;

    @Before
    public void setUp() {
        // 清空测试数据
        jedis.del(GEO_KEY);
    }

    @After
    public void tearDown() {
        // 清理测试数据
        jedis.del(GEO_KEY);
        System.out.println("Test data cleaned up");
    }

    @Test
    public void testGeoaddAndGeopos() {
        // 添加地理位置
        long addedBeijing = jedis.geoadd(GEO_KEY, BEIJING_LON, BEIJING_LAT, "Beijing");
        assertEquals(1, addedBeijing);

        long addedShanghai = jedis.geoadd(GEO_KEY, SHANGHAI_LON, SHANGHAI_LAT, "Shanghai");
        assertEquals(1, addedShanghai);

        System.out.println("GEOADD operations successful");

        // 获取地理位置
        List<GeoCoordinate> coordinates = jedis.geopos(GEO_KEY, "Beijing", "Shanghai", "NonExistCity");
        assertNotNull(coordinates);
        assertEquals(3, coordinates.size());

        // 验证北京坐标
        GeoCoordinate beijingCoord = coordinates.get(0);
        assertNotNull(beijingCoord);
        assertEquals(BEIJING_LON, beijingCoord.getLongitude(), 0.00001);
        assertEquals(BEIJING_LAT, beijingCoord.getLatitude(), 0.00001);

        // 验证上海坐标
        GeoCoordinate shanghaiCoord = coordinates.get(1);
        assertNotNull(shanghaiCoord);
        assertEquals(SHANGHAI_LON, shanghaiCoord.getLongitude(), 0.00001);
        assertEquals(SHANGHAI_LAT, shanghaiCoord.getLatitude(), 0.00001);

        // 验证不存在的城市
        assertNull(coordinates.get(2));

        System.out.println("GEOPOS operation successful");
        System.out.println("Beijing coordinates: " + beijingCoord);
        System.out.println("Shanghai coordinates: " + shanghaiCoord);
    }

    @Test
    public void testGeodist() {
        // 准备测试数据
        jedis.geoadd(GEO_KEY, BEIJING_LON, BEIJING_LAT, "Beijing");
        jedis.geoadd(GEO_KEY, SHANGHAI_LON, SHANGHAI_LAT, "Shanghai");
        jedis.geoadd(GEO_KEY, GUANGZHOU_LON, GUANGZHOU_LAT, "Guangzhou");

        // 计算距离(千米)
        Double distance = jedis.geodist(GEO_KEY, "Beijing", "Shanghai", GeoUnit.KM);
        assertNotNull(distance);
        assertTrue(distance > 1000 && distance < 1200); // 北京到上海实际距离约1064公里
        System.out.println("GEODIST operation successful - Distance: " + distance + " km");

        // 计算距离(米)
        Double distanceMeters = jedis.geodist(GEO_KEY, "Beijing", "Shanghai", GeoUnit.M);
        assertEquals(distance * 1000, distanceMeters, 100); // 允许100米误差

        // 测试不存在的城市
        Double nonExistDist = jedis.geodist(GEO_KEY, "Beijing", "NonExistCity", GeoUnit.KM);
        assertNull(nonExistDist);
        System.out.println("GEODIST with non-existent city returns null");
    }

    @Test
    public void testGeoradius() {
        // 准备测试数据
        jedis.geoadd(GEO_KEY, BEIJING_LON, BEIJING_LAT, "Beijing");
        jedis.geoadd(GEO_KEY, SHANGHAI_LON, SHANGHAI_LAT, "Shanghai");
        jedis.geoadd(GEO_KEY, GUANGZHOU_LON, GUANGZHOU_LAT, "Guangzhou");

        // 查找附近的位置(500公里范围内)
        List<GeoRadiusResponse> nearby = jedis.georadius(GEO_KEY, BEIJING_LON, BEIJING_LAT, 500, GeoUnit.KM);
        assertNotNull(nearby);
        assertEquals(1, nearby.size()); // 只有北京自己在500公里范围内
        assertEquals("Beijing", nearby.get(0).getMemberByString());
        System.out.println("GEORADIUS operation successful (500km) - Nearby cities: " + nearby.size());

        // 查找附近的位置(1500公里范围内)
        List<GeoRadiusResponse> widerNearby = jedis.georadius(GEO_KEY, BEIJING_LON, BEIJING_LAT, 1500, GeoUnit.KM);
        assertNotNull(widerNearby);
        assertEquals(2, widerNearby.size()); // 北京和上海
        System.out.println("GEORADIUS operation successful (1500km) - Nearby cities: " + widerNearby.size());

        // 测试带选项的GEORADIUS
        GeoRadiusParam param = new GeoRadiusParam()
                .withCoord()
                .withDist()
                .sortAscending()
                .count(2);

        List<GeoRadiusResponse> nearbyWithParams = jedis.georadius(
                GEO_KEY, BEIJING_LON, BEIJING_LAT, 2000, GeoUnit.KM, param);

        assertNotNull(nearbyWithParams);
        assertEquals(2, nearbyWithParams.size());
        assertTrue(nearbyWithParams.get(0).getDistance() <= nearbyWithParams.get(1).getDistance());
        System.out.println("GEORADIUS with params successful - Results: " + nearbyWithParams);
    }

    @Test
    public void testGeoradiusByMember() {
        // 准备测试数据
        jedis.geoadd(GEO_KEY, BEIJING_LON, BEIJING_LAT, "Beijing");
        jedis.geoadd(GEO_KEY, SHANGHAI_LON, SHANGHAI_LAT, "Shanghai");
        jedis.geoadd(GEO_KEY, GUANGZHOU_LON, GUANGZHOU_LAT, "Guangzhou");

        // 以北京为中心查找附近位置
        List<GeoRadiusResponse> nearby = jedis.georadiusByMember(
                GEO_KEY, "Beijing", 1500, GeoUnit.KM);

        assertNotNull(nearby);
        assertEquals(2, nearby.size()); // 北京和上海
        System.out.println("GEORADIUSBYMEMBER operation successful - Nearby cities: " + nearby.size());

        // 测试带选项的GEORADIUSBYMEMBER
        GeoRadiusParam param = new GeoRadiusParam()
                .withCoord()
                .withDist()
                .sortDescending();

        List<GeoRadiusResponse> nearbyWithParams = jedis.georadiusByMember(
                GEO_KEY, "Beijing", 2000, GeoUnit.KM, param);

        assertNotNull(nearbyWithParams);
        assertEquals(3, nearbyWithParams.size()); // 北京、上海、广州
        assertTrue(nearbyWithParams.get(0).getDistance() >= nearbyWithParams.get(1).getDistance());
        System.out.println("GEORADIUSBYMEMBER with params successful - Results: " + nearbyWithParams);
    }

    @Test
    public void testGeoHash() {
        // 准备测试数据
        jedis.geoadd(GEO_KEY, BEIJING_LON, BEIJING_LAT, "Beijing");
        jedis.geoadd(GEO_KEY, SHANGHAI_LON, SHANGHAI_LAT, "Shanghai");

        // 获取Geohash
        List<String> hashes = jedis.geohash(GEO_KEY, "Beijing", "Shanghai");
        assertNotNull(hashes);
        assertEquals(2, hashes.size());

        // 验证Geohash格式
        assertTrue(hashes.get(0).matches("^[0-9a-z]+$")); // 北京
        assertTrue(hashes.get(1).matches("^[0-9a-z]+$")); // 上海
        System.out.println("GEOHASH operation successful");
        System.out.println("Beijing geohash: " + hashes.get(0));
        System.out.println("Shanghai geohash: " + hashes.get(1));
    }
}

9、消息队列操作

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.*;

public class RedisPubSubTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private Jedis publisherJedis;
    private Jedis subscriberJedis;
    private static final String CHANNEL = "testChannel";
    private static final String MESSAGE = "testMessage";
    
    @Before
    public void setUp() {
        // 创建独立的连接用于发布和订阅
        publisherJedis = new Jedis(HOST, PORT);
        subscriberJedis = new Jedis(HOST, PORT);
    }
    
    @After
    public void tearDown() {
        if (publisherJedis != null) {
            publisherJedis.close();
        }
        if (subscriberJedis != null) {
            subscriberJedis.close();
        }
        System.out.println("Resources cleaned up");
    }

    @Test
    public void testPubSub() throws InterruptedException {
        // 使用CountDownLatch等待消息接收
        CountDownLatch messageReceived = new CountDownLatch(1);
        
        // 创建订阅者
        JedisPubSub jedisPubSub = new JedisPubSub() {
            @Override
            public void onMessage(String channel, String message) {
                System.out.println("Received message: " + message + " from channel: " + channel);
                assertEquals(CHANNEL, channel);
                assertEquals(MESSAGE, message);
                messageReceived.countDown();
            }
            
            @Override
            public void onSubscribe(String channel, int subscribedChannels) {
                System.out.println("Subscribed to channel: " + channel);
            }
        };
        
        // 在单独线程中订阅
        new Thread(() -> {
            System.out.println("Starting subscriber...");
            subscriberJedis.subscribe(jedisPubSub, CHANNEL);
        }).start();
        
        // 等待订阅成功
        Thread.sleep(1000);
        
        // 发布消息
        long subscribers = publisherJedis.publish(CHANNEL, MESSAGE);
        assertTrue(subscribers > 0);
        System.out.println("Published message to " + subscribers + " subscribers");
        
        // 等待消息接收（最多等待5秒）
        boolean received = messageReceived.await(5, TimeUnit.SECONDS);
        assertTrue("Message not received within timeout", received);
        
        // 取消订阅
        jedisPubSub.unsubscribe();
    }

    @Test
    public void testPatternSubscribe() throws InterruptedException {
        // 使用CountDownLatch等待消息接收
        CountDownLatch messageReceived = new CountDownLatch(1);
        String patternChannel = "test.*";
        String specificChannel = "test.pattern";
        
        // 创建模式订阅者
        JedisPubSub jedisPubSub = new JedisPubSub() {
            @Override
            public void onPMessage(String pattern, String channel, String message) {
                System.out.println("Received message: " + message + 
                                 " from channel: " + channel + 
                                 " matching pattern: " + pattern);
                assertEquals(patternChannel, pattern);
                assertEquals(specificChannel, channel);
                assertEquals(MESSAGE, message);
                messageReceived.countDown();
            }
            
            @Override
            public void onPSubscribe(String pattern, int subscribedChannels) {
                System.out.println("Subscribed to pattern: " + pattern);
            }
        };
        
        // 在单独线程中订阅模式
        new Thread(() -> {
            System.out.println("Starting pattern subscriber...");
            subscriberJedis.psubscribe(jedisPubSub, patternChannel);
        }).start();
        
        // 等待订阅成功
        Thread.sleep(1000);
        
        // 发布消息到匹配模式的频道
        long subscribers = publisherJedis.publish(specificChannel, MESSAGE);
        assertTrue(subscribers > 0);
        System.out.println("Published message to " + subscribers + " subscribers");
        
        // 等待消息接收（最多等待5秒）
        boolean received = messageReceived.await(5, TimeUnit.SECONDS);
        assertTrue("Message not received within timeout", received);
        
        // 取消订阅
        jedisPubSub.punsubscribe();
    }

    @Test
    public void testMultipleChannels() throws InterruptedException {
        String channel1 = "channel1";
        String channel2 = "channel2";
        CountDownLatch messagesReceived = new CountDownLatch(2);
        
        // 创建订阅者
        JedisPubSub jedisPubSub = new JedisPubSub() {
            @Override
            public void onMessage(String channel, String message) {
                System.out.println("Received message from channel: " + channel);
                messagesReceived.countDown();
            }
        };
        
        // 在单独线程中订阅多个频道
        new Thread(() -> {
            System.out.println("Starting multi-channel subscriber...");
            subscriberJedis.subscribe(jedisPubSub, channel1, channel2);
        }).start();
        
        // 等待订阅成功
        Thread.sleep(1000);
        
        // 发布消息到两个频道
        publisherJedis.publish(channel1, MESSAGE);
        publisherJedis.publish(channel2, MESSAGE);
        
        // 等待消息接收（最多等待5秒）
        boolean received = messagesReceived.await(5, TimeUnit.SECONDS);
        assertTrue("Not all messages received within timeout", received);
        
        // 取消订阅
        jedisPubSub.unsubscribe();
    }
}

10、事务操作

package cn.kdyzm.jedis.demo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.exceptions.JedisDataException;

import java.util.List;

import static org.junit.Assert.*;

public class RedisTransactionTest {

    private static final String HOST = "192.168.203.130";
    private static final int PORT = 6379;
    private Jedis jedis;
    private static final String KEY1 = "txKey1";
    private static final String KEY2 = "txKey2";
    private static final String COUNTER = "txCounter";

    @Before
    public void setUp() {
        jedis = new Jedis(HOST, PORT);
        // 清空测试数据
        jedis.del(KEY1, KEY2, COUNTER);
    }

    @After
    public void tearDown() {
        if (jedis != null) {
            jedis.close();
        }
        System.out.println("Resources cleaned up");
    }

    @Test
    public void testSuccessfulTransaction() {
        // 开启事务
        Transaction tx = jedis.multi();
        System.out.println("Transaction started");

        // 执行命令
        tx.set(KEY1, "value1");
        tx.set(KEY2, "value2");
        tx.incr(COUNTER);
        System.out.println("Commands added to transaction");

        // 执行事务
        List<Object> results = tx.exec();
        assertNotNull(results);
        assertEquals(3, results.size());
        System.out.println("Transaction executed successfully");

        // 验证结果
        assertEquals("OK", results.get(0));
        assertEquals("OK", results.get(1));
        assertEquals(1L, results.get(2));

        // 验证数据
        assertEquals("value1", jedis.get(KEY1));
        assertEquals("value2", jedis.get(KEY2));
        assertEquals("1", jedis.get(COUNTER));
        System.out.println("Data verification successful");
    }

    @Test
    public void testDiscardedTransaction() {
        // 开启事务
        Transaction tx = jedis.multi();
        System.out.println("Transaction started");

        // 执行命令
        tx.set(KEY1, "value1");
        tx.set(KEY2, "value2");
        System.out.println("Commands added to transaction");

        // 放弃事务
        String discardResult = tx.discard();
        assertEquals("OK", discardResult);
        System.out.println("Transaction discarded successfully");

        // 验证数据未被修改
        assertNull(jedis.get(KEY1));
        assertNull(jedis.get(KEY2));
        System.out.println("Data remains unchanged after discard");
    }

    @Test(expected = IllegalStateException.class)
    public void testWatchAndConflict() {
        // 监视键
        jedis.watch(KEY1);
        System.out.println("Watching key: " + KEY1);

        // 开启事务
        Transaction tx = jedis.multi();
        System.out.println("Transaction started");

        // 尝试修改被监视的键
        tx.set(KEY1, "transactionValue");
        System.out.println("Attempting to modify watched key in transaction");

        // 在事务外修改被监视的键，此处应该抛出IllegalStateException异常
        jedis.set(KEY1, "externalChange");
        System.out.println("Key modified outside transaction");

        // 执行事务（应该失败）
        tx.exec();
        System.out.println("This line should not be reached");
    }

    @Test
    public void testWatchAndNoConflict() {
        // 监视键
        jedis.watch(KEY1);
        System.out.println("Watching key: " + KEY1);

        // 开启事务
        Transaction tx = jedis.multi();
        System.out.println("Transaction started");

        // 修改被监视的键
        tx.set(KEY1, "transactionValue");
        System.out.println("Modifying watched key in transaction");

        // 执行事务（应该成功，因为没有冲突）
        List<Object> results = tx.exec();
        assertNotNull(results);
        assertEquals(1, results.size());
        assertEquals("OK", results.get(0));
        System.out.println("Transaction executed successfully with no conflicts");

        // 验证数据
        assertEquals("transactionValue", jedis.get(KEY1));
        System.out.println("Data verification successful");
    }

    @Test
    public void testTransactionWithError() {
        // 设置一个非数字值
        jedis.set(COUNTER, "notANumber");

        // 开启事务
        Transaction tx = jedis.multi();
        System.out.println("Transaction started");

        // 执行命令（包含一个会失败的命令）
        tx.set(KEY1, "value1");
        tx.incr(COUNTER); // 这会失败，但是会继续执行剩下的命令
        tx.set(KEY2, "value2");
        System.out.println("Commands added to transaction (one will fail)");

        // 执行事务
        try {
            tx.exec();
        } catch (JedisDataException e) {
            System.out.println("Transaction failed as expected: " + e.getMessage());
        }

        // 验证部分命令未执行
        assertNotNull(jedis.get(KEY1));
        assertNotNull(jedis.get(KEY2));
        assertEquals("notANumber", jedis.get(COUNTER));
        System.out.println("No commands were executed due to transaction failure");
    }
}

四、注意事项

jedis在实际开发中直接使用的可能性比较低，由于springboot官方有redis spring boot starter，我们一般习惯性的基于该组件操作redis。

END.

DiskGenius磁盘扩容报错“$Bitmap中有标记为已使用的未用簇”解决方法

Mon, 28 Jul 2025 22:47:37 +0800

使用DiskGenius进行磁盘扩容的时候报错：

$Bitmap中有标记为已使用的未用簇。簇号:1391898
$MFT位图中有标记为已使用的未用文件记录。文件:1340

解决方法就是在命令行运行：

chkdsk /f /x e:

其中e: 需要根据提示换成自己的盘符。修复完成之后重新进行磁盘扩容，就能成功了。

END.

Linux命令系列：vim命令

Sat, 26 Jul 2025 19:55:18 +0800

一、vim命令的三种模式

Vim中有三种模式：编辑模式、输入模式、末行模式。使用vim命令打开文件之后默认处于编辑模式下。

编辑模式-->输入模式：

i：在当前光标所在字符的前面，转换成为输入模式

a：在当前光标所在字符的后面，转换为输入模式

o：在当前光标所在行的下方新建一行，并转换为输入模式

I：在当前光标所在行的行首，转换为输入模式

A：在当前光标所在行的行尾，转换为输入模式

O：在当前光标所在行的上方新建一行，并转换成为输入模式

输入模式-->编辑模式：

ESC

编辑模式-->末行模式：

末行模式-->编辑模式：

ESC,ESC

输入模式不能直接转换到末行模式，必须先转换成为编辑模式再转换到末行模式。

二、文件的打开和关闭

1、打开文件

vim +# FILENAME：打开文件，并定位到文件的第#行

vim + FILENAME：打开文件，并定位到最后一行

vim +/PATTERN ：打开文件，并定位到第一次被PATTERN匹配到的行的行首

打开文件之后默认处于编辑模式

2、关闭文件

末行模式下关闭文件：

输入	功能
:q	退出
:q!	不保存并退出
:wq或者:x	保存并退出
:w	保存
:w!	强行保存

编辑模式下退出：

ZZ：保存并退出

强行退出：

Ctrl+C，使用这种方式的结果就是会产生.swp文件，这种文件会保存未保存的内容以便于下一次编辑文件的时候进行恢复，所以比较麻烦，强烈不建议直接Ctrl+C退出，按照正常流程退出的话就不会产生这种文件了。

三、编辑模式下的操作

使用vim大多数情况下都是在编辑模式下操作，编辑模式是vim中使用率最高的模式。

1、光标移动

逐字符移动光标：

快捷键	功能
h	向左移动一个字符
j	向下移动一个字符
k	向上移动一个字符
l	向右移动一个字符
#h \| j \| k \| l	向左\|下\|上\|右移动一个字符

逐单词移动光标：

快捷键	功能
w	跳转到下一个单词的首部
b	跳转到上一个单词的首部
e	跳转到下一个单词的尾部
#w	跳转到下#个单词的首部
#b	跳转到上#个单词的首部
#e	跳转到下#个单词的尾部

行内跳转：

快捷键	功能
0	跳转到绝对行首
$	跳转到绝对行尾
^	跳转到行首第一个非空白字符处

行间跳转：

快捷键	功能
gg	跳转到第一行
G \| :$	跳转到最后一行
#G \| :#	跳转到第#行

翻屏跳转：

快捷键	功能
Ctrl+f	向下翻一屏
Ctrl+b	向上翻一屏
Ctrl+d	向下翻半屏
Ctrl+u	向上翻半屏

2、删除操作

删除字符：

快捷键	功能
x	删除光标所在处的字符
#x	删除光标所在处及向后的共#个字符

删除单词：

快捷键	功能
[#]dw	删除光标所在处的#个单词
[#]db	删除光标所在处之前的#个单词
[#]de	删除光标所在处之后的#个单词，注意和dw之间的区别

删除行：

快捷键	功能
dd	删除光标所在处的行
#dd	删除当前光标所在行以及向下共#行

3、复制粘贴

复制： 使用y命令，使用方法和d命令完全相同，比如yw表示复制光标所在处的单词,yy复制当前行。

粘贴： 使用d命令删除的内容和使用y命令复制的内容都保存到了系统粘贴板上，使用p或者P命令能够粘贴到指定的位置上。

p命令：如果复制或删除的是非整行则粘贴至当前光标所在字符的后面，如果复制或删除的是整行，则会粘贴到当前光标所在行的下方。
P命令：如果复制或删除的是非整行则粘贴至当前光标所在字符的前面，如果复制或删除的是整行，则会粘贴到当前光标所在行的上方。

4、撤销和反撤销

快捷键	功能
u	撤销上一次操作
#u	撤销最近#次操作
Ctrl+r	反撤销最近一次操作

5、可视化

快捷键	功能
v	按照字符选取
V	按照行选取

6、查找

快捷键	功能
/	向下查找
?	向上查找

7、替换

替换的命令语法和sed命令语法完全相同

ADDR1,ADDR2 s/PATTERN/string/gi

可以使用1,$指定全文范围，但是可以使用%代替之。

四、末行模式下的操作

1.显示或者取消显示行号

命令	功能
:set number \| set nu	显示行号
:set nonumber \| set nonu	不显示行号

2.显示忽略或者区分字符大小写

命令	功能
:set ignorecase \| set ic	忽略大小写
:set noignorecase \| set noic	区分大小写

3.设定自动缩进

命令	功能
:set autoindent \| set ai	设置自动缩进
:set noautoindent \| set noai	取消自动缩进

4.查找到的文本高亮显示或者取消

命令	功能
:set hlsearch	查找到的文本高亮显示
:set nohlsearch	取消查找到的文本高亮显示

5.语法高亮

命令	功能
:syntax on	语法高亮
:syntax off	取消语法高亮

五、配置文件

命令	功能
/etc/vimrc	全局配置文件
~/.vimrc	个人配置文件

Linux命令系列：man命令

Fri, 25 Jul 2025 16:05:10 +0800

介绍man命令之前，先运行如下命令以保证文档包可用：

yum install man-pages shadow-utils

man 命令是 Linux/Unix 系统中用于查看命令、函数或配置文件手册页（manual pages）的核心工具。其基本语法格式如下：

man [选项] [章节号] <命令名/函数名/配置文件>

man命令将输入分为了九类，被称为九个章节：

1   可执行程序或 shell 命令
2   系统调用(内核提供的函数)
3   库调用(程序库中的函数)
4   特殊文件(通常位于 /dev)
5   文件格式和规范，如 /etc/passwd
6   游戏
7   杂项(包括宏包和规范，如 man(7)，groff(7))
8   系统管理命令(通常只针对 root 用户)
9   内核例程 [非标准

输入的命令可能在这九个章节中的某几个章节中有内容，比如passwd命令，使用man -wa passwd可以看到它属于哪几个章节，即哪几个章节中会有内容：

[root@localhost ~]# man -wa passwd
/usr/share/man/man1/passwd.1.gz
/usr/share/man/man1/sslpasswd.1ssl.gz
/usr/share/man/man5/passwd.5.gz

可以看到passwd命令在章节1和章节5有内容，则可以使用man 1 passwd或者man 5 passwd命令查看相关文档。

常见选项：

-f：显示与指定关键字相关的手册页面。
-k：搜索手册页中与关键字匹配的条目。
-a：显示所有匹配的手册页面。
-w：仅显示手册页的位置，而不显示其内容。

比如我们想查看匹配的手册页面，可以使用-wa选项，正如之前说的查看passwd的手册页面：

[root@localhost ~]# man -wa passwd
/usr/share/man/man1/passwd.1.gz
/usr/share/man/man1/sslpasswd.1ssl.gz
/usr/share/man/man5/passwd.5.gz

交互快捷键：

翻页：空格 / d（下一页）、b / u（上一页）
逐行：j / 回车（下一行）、k（上一行）
搜索：/keyword（向前搜索）、?keyword（向后搜索）
跳转：g（开头）、G（末尾）
退出：q

Redis（十）：使用redis-cli工具操作redis集群

Thu, 24 Jul 2025 23:28:22 +0800

上一篇文章《Redis（九）：多机部署之Cluster（集群）模式》中，已经介绍过Redis集群的搭建以及在redis-cli中使用命令操作redis集群。实际上可以不用进入redis-cli，而是直接通过redis-cli程序使用--cluster功能项直接操作集群，其底层实际上也是使用了redis命令。那为什么还要使用redis-cli --cluster功能项呢？因为其更简单，功能更强大。在上一篇文章介绍cluster setslot命令时，使用redis cluster命令需要经过四步才能将槽成功迁移；使用--cluster功能项，则使用一条语句就能实现类似的槽迁移功能。

./redis-cli --cluster reshard 127.0.0.1:30002 --cluster-from 9d148120512f85f29dd246e515243fd6019c7dcc --cluster-to d85dc362370f81fe627305e9b246365bd51a02c2 --cluster-slots 1

很明显，使用redis-cli的--cluster子命令可以大幅度提高集群的操作效率。

一、redis-cli简介

一般我们使用redis-cli的目的是进入某个服务器节点交互式执行一些命令，比如我们可以使用./redis-cli -h 127.0.0.1 -p 6379命令进入6379服务的交互控制台。除了进入控制台，redis-cli还可以不进入交互控制台，直接执行一些命令，其支持的命令可以使用./redis-cli --help查看。

分类	选项	描述	默认值/示例
连接相关	`-h <hostname>`	指定 Redis 服务器主机名	`127.0.0.1`
	`-p <port>`	指定 Redis 服务器端口	`6379`
	`-s <socket>`	使用 Unix 套接字连接（覆盖主机名和端口）
	`-a <password>`	连接服务器的密码（也可用 `REDISCLI_AUTH` 环境变量）
	`--user <username>`	使用 ACL 风格认证（需配合 `-a`）
	`--askpass`	强制从 STDIN 输入密码（忽略 `-a` 和环境变量）
	`-u <uri>`	使用 URI 格式连接（如 `redis://user:pass@host:port`）
	`-n <db>`	选择数据库编号
命令执行	`-r <repeat>`	重复执行命令 N 次	`redis-cli -r 100 INCR counter`
	`-i <interval>`	配合 `-r` 设置命令间隔时间（支持小数秒）	`-i 0.1`（0.1秒间隔）
	`-x`	从 STDIN 读取最后一个参数	`cat file.txt
	`-e`	命令失败时返回错误退出码
	`--eval <file>`	执行 Lua 脚本文件	`--eval script.lua key1 key2 , arg1`
	`--ldb`	启用 Lua 调试器（异步模式）
输出格式	`--raw`	原始格式输出（非终端时默认）
	`--no-raw`	强制格式化输出（即使是非终端）
	`--csv`	CSV 格式输出
	`-d <delimiter>`	设置原始格式的批量响应分隔符	默认 `\n`
	`--show-pushes <yn>`	控制是否显示 RESP3 PUSH 消息	默认根据终端类型决定
监控与诊断	`--stat`	显示服务器滚动统计（内存、客户端等）
	`--latency`	实时延迟监控模式
	`--latency-history`	延迟历史记录（默认15秒间隔）	`-i 5` 修改间隔
	`--bigkeys`	查找包含大量元素的键
	`--hotkeys`	查找热点键（需 LFU 策略）
	`--scan --pattern <pat>`	扫描匹配模式的键	默认 `*`
特殊模式	`-c`	集群模式（跟随重定向）
	`--pipe`	将原始协议从 STDIN 传输到服务器	`cat data.txt
	`--replica`	模拟副本显示主服务器命令
数据操作	`--rdb <filename>`	将远程服务器的 RDB 转储保存到本地文件	`--rdb dump.rdb`
集群管理	`--cluster <command>`	执行集群管理命令（如 `--cluster help`）
其他	`--help`	显示帮助信息
	`--version`	显示版本信息

比如我们使用命令./redis-cli -p 6379进入控制台之后使用get命令获取键值，如果键值中有中文，则可能会出现中文乱码，解决方法就是使用使用--raw选项，使用./redis-cli -p 6379 --raw重新进入控制台就可以解决问题了。

接下来讲解redis-cli集群管理相关的功能。

二、redis-cli集群管理工具

redis-cli客户端附带的集群管理程序使用--cluster选项开启。先使用help命令查看其有多少子命令可用。

[root@localhost demo_redis_6.2.1]# ./redis-cli --cluster help
Cluster Manager Commands:
  create         host1:port1 ... hostN:portN
                 --cluster-replicas <arg>
  check          host:port
                 --cluster-search-multiple-owners
  info           host:port
  fix            host:port
                 --cluster-search-multiple-owners
                 --cluster-fix-with-unreachable-masters
  reshard        host:port
                 --cluster-from <arg>
                 --cluster-to <arg>
                 --cluster-slots <arg>
                 --cluster-yes
                 --cluster-timeout <arg>
                 --cluster-pipeline <arg>
                 --cluster-replace
  rebalance      host:port
                 --cluster-weight <node1=w1...nodeN=wN>
                 --cluster-use-empty-masters
                 --cluster-timeout <arg>
                 --cluster-simulate
                 --cluster-pipeline <arg>
                 --cluster-threshold <arg>
                 --cluster-replace
  add-node       new_host:new_port existing_host:existing_port
                 --cluster-slave
                 --cluster-master-id <arg>
  del-node       host:port node_id
  call           host:port command arg arg .. arg
                 --cluster-only-masters
                 --cluster-only-replicas
  set-timeout    host:port milliseconds
  import         host:port
                 --cluster-from <arg>
                 --cluster-from-user <arg>
                 --cluster-from-pass <arg>
                 --cluster-from-askpass
                 --cluster-copy
                 --cluster-replace
  backup         host:port backup_directory
  help           

For check, fix, reshard, del-node, set-timeout you can specify the host and port of any working node in the cluster.

Cluster Manager Options:
  --cluster-yes  Automatic yes to cluster commands prompts

可以看到有很多子命令，接下来看看每个子命令的用法。

create：创建集群

create子命令允许用户根据已有的节点创建出一个集群。用户只需要在命令中依次给出各个节点的IP地址和端口号，命令就会将它们聚合到同一个集群中，并根据节点的数量将槽平均地指派给它们负责，完整命令如下所示：

./redis-cli --cluster create host1:port1 ... hostN:portN --cluster-replicas <arg>

--cluster-replicas 选项可选，用于指定每个master节点有多少个副本。

比如我们之前创建了包含5个主节点，5个父节点的集群：

./redis-cli --cluster create \  #创建集群命令
127.0.0.1:30001 127.0.0.1:30002 127.0.0.1:30003 127.0.0.1:30004 127.0.0.1:30005 127.0.0.1:30006 127.0.0.1:30007 127.0.0.1:30008 127.0.0.1:30009 127.0.0.1:30010 \ #指定10个节点的ip和端口号
--cluster-replicas 1  #每个主节点1个副本

check：检查集群

通过cluster选项的check子命令，用户可以检查集群的配置是否正确，以及全部16384个槽是否已经全部指派给了主节点。该命令接受集群中任意一个节点的ip和端口号作为参数，完整命令如下所示：

./redis-cli --cluster check host:port --cluster-search-multiple-owners

--cluster-search-multiple-owners选项可选，用于着重验证每个哈希槽是否只被一个节点拥有。运行示例如下所示：

./redis-cli --cluster check 127.0.0.1:30001 --cluster-search-multiple-owners

输出如下：

info：查看集群信息

用户可以通过cluster选项的info子命令查看集群的相关信息。完整命令格式如下所示：

./redis-cli --cluster info host:port

host:port是集群中任意节点的ip和端口号。

其输出包括：有多少个主节点，每个主节点有几个副本节点，分配了多少槽以及节点中有多少key。

./redis-cli --cluster info 127.0.0.1:30001

输出如下所示：

fix：修复集群状态错误

当集群在重分片、负载均衡或者槽迁移的过程中出现错误时或者集群状态错误时，执行cluster选项的fix子命令，可以让操作涉及的槽重新回到正常状态：

./redis-cli --cluster fix host:port #集群中任意节点的地址和端口号
--cluster-search-multiple-owners #检查并修复哈希槽（hash slot）被多个节点同时声明的冲突问题
--cluster-fix-with-unreachable-masters #即使某些主节点不可达，仍然尝试修复集群状态。

使用该命令前应当先试用check子命令检查集群问题，确认问题后再运行该命令修复。如果集群没问题，运行该命令不会做任何操作：

./redis-cli --cluster fix 127.0.0.1:30001 --cluster-search-multiple-owners --cluster-fix-with-unreachable-masters

可以看到运行fix命令后，内部应该先调用了check命令检查了集群状态，如果没发现错误则不会进行修复操作。

reshard：重分片

通过cluster选项的reshard子命令，用户可以将指定数量的槽从原节点迁移至目标节点，被迁移的槽将交由后者负责，并且槽中已有的数据也会陆续从原节点转移至目标节点，该命令常用于集群扩容/缩容：

./redis-cli --cluster reshard host:port  #集群中任意一个节点的地址和端口
 --cluster-from <node-id>			#源节点     	
 --cluster-to <node-id>				#目标节点
 --cluster-slots <num-slots>			#要迁移的槽数量
 --cluster-yes					#跳过确认提示
 --cluster-timeout <milliseconds>		#超时时间（默认 60000ms）
 --cluster-pipeline <num>		#批量迁移 key 的数量（默认 10）
 --cluster-replace				#强制替换目标节点上的现有数据

该命令的作用：

重新分配哈希槽（reshard），调整数据分布。
支持手动指定源节点和目标节点，或让 Redis 自动选择。
批量迁移 key，提高迁移效率。
适用于集群扩容或缩容（如新增节点后需要均衡数据）。

该命令有两种模式：手动交互模式以及全自动模式。

手动交互模式

手动交互模式只需要执行./redis-cli --cluster reshard host:port就会进入交互模式，根据提示输入信息，比如待迁移的节点id、槽数量等最后提交即可完成迁移。比如现在30001节点下有0到3276槽，我们现在将30001节点下的一个槽迁移到30011：

[root@localhost demo_redis_6.2.1]# ./redis-cli --cluster reshard 127.0.0.1:30001
>>> Performing Cluster Check (using node 127.0.0.1:30001)
M: d85dc362370f81fe627305e9b246365bd51a02c2 127.0.0.1:30001
   slots:[0-3276] (3277 slots) master
   1 additional replica(s)
S: d5f1adb8939529abcfe24e657bd01787b7d7928c 127.0.0.1:30003
   slots: (0 slots) slave
   replicates 32661eb91b3be79b9a9d9ba873e1066bd64916a7
M: 32661eb91b3be79b9a9d9ba873e1066bd64916a7 127.0.0.1:30010
   slots:[6554-9829] (3276 slots) master
   1 additional replica(s)
M: adbbff5339b083b1e4fb641951e6fb9085ffb25c 127.0.0.1:30005
   slots:[13107-16383] (3277 slots) master
   1 additional replica(s)
S: 1728a0fb708c776303f25e33c0add3297332cd64 127.0.0.1:30007
   slots: (0 slots) slave
   replicates 6d2c221d2ff15ae7fb9d5a5b7551ae5b493e791f
S: 0db0c21f6f9b075b887c0ef1548cf35cb0505b0b 127.0.0.1:30009
   slots: (0 slots) slave
   replicates adbbff5339b083b1e4fb641951e6fb9085ffb25c
S: c33e236a553d9e658a0bb549d933567de5a756f8 127.0.0.1:30006
   slots: (0 slots) slave
   replicates 9d148120512f85f29dd246e515243fd6019c7dcc
M: 9d148120512f85f29dd246e515243fd6019c7dcc 127.0.0.1:30002
   slots:[3277-6553] (3277 slots) master
   1 additional replica(s)
S: dd7079d8486119fecc4e71f10fb705889ea8668b 127.0.0.1:30008
   slots: (0 slots) slave
   replicates d85dc362370f81fe627305e9b246365bd51a02c2
M: 6d2c221d2ff15ae7fb9d5a5b7551ae5b493e791f 127.0.0.1:30004
   slots:[9830-13106] (3277 slots) master
   1 additional replica(s)
M: 79a28e2df5e13dd726c892c42ee35a15423b00fb 127.0.0.1:30011
   slots: (0 slots) master
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 1
What is the receiving node ID? 79a28e2df5e13dd726c892c42ee35a15423b00fb
Please enter all the source node IDs.
  Type 'all' to use all the nodes as source nodes for the hash slots.
  Type 'done' once you entered all the source nodes IDs.
Source node #1: d85dc362370f81fe627305e9b246365bd51a02c2
Source node #2: done

Ready to move 1 slots.
  Source nodes:
    M: d85dc362370f81fe627305e9b246365bd51a02c2 127.0.0.1:30001
       slots:[0-3276] (3277 slots) master
       1 additional replica(s)
  Destination node:
    M: 79a28e2df5e13dd726c892c42ee35a15423b00fb 127.0.0.1:30011
       slots: (0 slots) master
  Resharding plan:
    Moving slot 0 from d85dc362370f81fe627305e9b246365bd51a02c2
Do you want to proceed with the proposed reshard plan (yes/no)? yes
Moving slot 0 from 127.0.0.1:30001 to 127.0.0.1:30011:

迁移完成之后，运行命令./redis-cli --cluster info 127.0.0.1:30001 查看集群槽分布情况：

可以看到30011节点上多了一个槽。

全自动模式

全自动模式就是将交互模式下需要输入的参数全放到了命令中，接下来使用全自动模式将30011节点上的1个槽迁移回30001：

./redis-cli --cluster reshard 127.0.0.1:30001  --cluster-from 79a28e2df5e13dd726c892c42ee35a15423b00fb --cluster-to d85dc362370f81fe627305e9b246365bd51a02c2  --cluster-slots 1

运行结果：

看似失败了，实际上已经成功了，可以运行./redis-cli --cluster info 127.0.0.1:30001命令检查：

可以看到30001节点的槽已经恢复，而且还多了一个从节点，同时，30011节点不见了。。可以猜想到发生了什么事情了：30011节点变成了30001节点的从节点了，更详细的信息可以通过./redis-cli --cluster check 127.0.0.1:30001命令查看。

为什么会发生这种事情呢？我们只是迁移了一个槽，为什会发生主节点降级成从节点的事情？

Redis集群有个特殊的机制，如果一个 主节点失去了所有槽位，Redis Cluster 可能会自动将其降级为从节点，在 Redis 6.2+ 中，如果一个主节点不再管理任何槽位，它可能会被 自动转换为从节点，以避免集群中出现无用的主节点。

我们的30001节点上只有一个槽，这最后一个槽迁移到30001节点上以后，它就失去了所有槽，然后就被自动降级成了从节点。

rebalance：负载均衡

该命令用于重新平衡Redis 集群的哈希槽（slots）分布，确保各个主节点的槽位数量尽可能均匀：

./redis-cli --cluster relalance host:port #集群中的任意一个节点地址
-cluster-weight <node1=w1...nodeN=wN> #指定节点的权重（影响槽位分配比例），node1=2 node2=1 表示 node1 分配 2 倍于 node2 的槽位
 --cluster-use-empty-masters 		#允许对没有槽位的主节点进行重新分配（默认会忽略它们）
 --cluster-timeout <arg>			#设置操作超时时间（单位：毫秒，默认 60000）
 --cluster-simulate					#模拟 rebalance，只显示计划，不实际执行
 --cluster-pipeline <arg>			#设置每次迁移的 key 数量（默认 10）
 --cluster-threshold <arg>			#设置触发 rebalance 的最小槽位差异（默认 2）。例如：如果节点间槽位数差异 ≤ 2，则不会触发 rebalance
 --cluster-replace					#强制替换故障节点（如果某些节点不可用）

比如我们的30011节点是新增的节点，就可以使用该命令将槽位重新均衡：

./redis-cli --cluster rebalance 127.0.0.1:30001 --cluster-use-empty-masters

运行结果：

可以看到，五个主节点都分别把自己的一部分槽分给了新增加的30011节点，使用./redis-cli --cluster info 127.0.0.1:30001命令查看集群节点信息：

可以看到集群中全部槽已经平均分配到了六个主节点中。

delnode：删除节点

当用户不再需要集群中的某个节点时，可以通过cluster选项的del-node子命令来移除该节点：

./redis-cli --cluster del-node host:port node_id

首先看看集群中的节点：

./redis-cli --cluster info 127.0.0.1:30001

集群中现在有6个节点，我想要把30011节点移除掉，运行如下命令：

./redis-cli --cluster del-node 127.0.0.1:30001 79a28e2df5e13dd726c892c42ee35a15423b00fb

移除节点失败了，因为redis集群不允许移除有数据的节点。

先使用reshard命令将全部的槽转移出去，再尝试：

./redis-cli --cluster reshard 127.0.0.1:30001  #使用交互式方式进行槽迁移，从30011转移全部的槽到30001

转移完成之后，重新查看集群信息：

可以看到30011已经没有槽了，此时再删除30011节点：

[root@localhost demo_redis_6.2.1]# ./redis-cli --cluster del-node 127.0.0.1:30001 79a28e2df5e13dd726c892c42ee35a15423b00fb
>>> Removing node 79a28e2df5e13dd726c892c42ee35a15423b00fb from cluster 127.0.0.1:30001
>>> Sending CLUSTER FORGET messages to the cluster...
>>> Sending CLUSTER RESET SOFT to the deleted node.

从日志中可以看到，实际上底层还是使用了cluster的内部集群命令cluster forget以及cluster reset。

删除完成之后在查看集群信息：

六个节点只剩了五个，30011节点已经被成功移除。但是槽1的槽数量比较多，可以使用rebalance进行负载均分下：

./redis-cli --cluster rebalance 127.0.0.1:30001

再次查看集群状态，槽数量已经均分到了五个节点：

add-node：添加节点

该命令的完整格式：

./redis-cli --cluster add-node 
    new_host:new_port 				#新节点地址
    existing_host:existing_port		#集群中现有任意节点地址，用于连接集群
    --cluster-slave					#指定新节点为从节点
    --cluster-master-id <master-id>		#指定主节点ID

新节点默认以主节点身份加入集群，使用--cluster-slave选项可以使其以从节点身份加入集群，如果指定了--cluster-master-id，则会被当做指定主节点的从节点；否则redis会自动为新节点选择一个主节点。

比如我们现在要将30011节点添加到集群，运行如下命令：

./redis-cli --cluster add-node 127.0.0.1:30011 127.0.0.1:30001

可以看到，实际上底层还是使用了cluster的内置命令meet将新节点加入集群的。查看集群状态：./redis-cli --cluster info 127.0.0.1:30001

可以看到新节点已经加入了集群，但是没有任何槽分配，可以使用rebalance命令进行槽均衡分配下：./redis-cli --cluster rebalance 127.0.0.1:30001 --cluster-use-empty-masters

再次查看集群状态，可以看到新节点30011已经分配了槽：

call：执行命令

通过cluster选项的call子命令，用户可以在整个集群的所有节点上执行给定的命令：

./redis-cli --cluster call           
host:port 					#集群任意节点，用于连接集群
command arg arg .. arg		#执行的命令
--cluster-only-masters		#只在master节点执行
--cluster-only-replicas		#只在从节点执行

该命令没什么好说的，尝试运行下get命令：

set-timeout：设置超时时间

通过cluster选项的set-timeout子命令，用户可以为集群的所有节点重新设置cluster-node-timeout选项的值：

./redis-cli --cluster set-timeout host:port milliseconds

超时时间单位是毫秒。

运行如下命令，将超时时间设置为5秒钟：

./redis-cli --cluster set-timeout 127.0.0.1:30001 5000

import：导入数据

import选项用于将某单机上的数据导入集群：

./redis-cli --cluster import 
host:port						#目标集群的任意节点地址
 --cluster-from <arg>			#源Redis实例地址
 --cluster-from-user <arg>		#源实例用户名（如果需要认证）
 --cluster-from-pass <arg>		#源实例密码（如果需要认证）
 --cluster-from-askpass			#交互式输入源实例密码
 --cluster-copy					#复制模式（保留源数据）
 --cluster-replace				#替换模式（覆盖冲突键）

接下来我们将6379单机redis的数据迁移到redis集群，运行如下命令：

./redis-cli --cluster import 127.0.0.1:30001 --cluster-from 127.0.0.1:6379 --cluster-copy --cluster-replace

backup：备份

./redis-cli --cluster backup host:port backup_directory

该命令用于将集群数据备份到本地目录，比如我们现在将集群备份到data目录：

./redis-cli --cluster backup 127.0.0.1:30001 ./data

看看data文件夹：

可以看到该选项将每个主节点的数据都存到了单独的rdb文件。

END.

Redis（九）：多机部署之Cluster（集群）模式

Tue, 22 Jul 2025 11:14:36 +0800

无论是主从复制模式，还是哨兵模式的主从复制模式，实际上都可以认为是“单机”部署的Redis实例，因为无论有多少从节点，主节点都只有一个，所有的数据写入都是写入主节点，从节点只是复制主节点而已。主从复制模式的缺点很明显，那就是无法水平扩展，如果数据量越来越大，对于单台机器的性能要求比较高。自Redis3.0开始，真正引入了Redis“集群”的概念，自此，Redis有了水平扩展的能力。

一、集群模式简介

与单机版Redis（包括主从复制模式）将整个数据库放在同一台服务器上的做法不同，Redis集群通过将数据库分散存储到多个节点上来平衡各个节点的负载压力。

具体来说，Redis集群会将整个数据库空间划分为16384个槽（slot）来实现数据分片（sharding），而集群中的各个主节点则会分别负责处理其中的一部分槽。当用户尝试将一个键存储到集群中时，客户端会先计算出键所属的槽，接着在记录集群节点槽分布的映射表中找出处理该槽的节点，最后再将键存储到相应的节点中，如下图所示：

Redis数据迁移的基本单位是槽（slot）。如果我们想新增一个节点，可以向集群发送几个命令，让集群把相应的槽以及槽内的数据迁移到新节点上；如果我们想删除一个节点，则集群会将被删除节点的槽迁移到其它节点上去。上述伴随着向集群新增或者删除节点导致槽迁移的过程被称为“重分片（reshard）”。无论是向集群中新增节点还是删除节点，整个重分片（reshard）过程都可以在线进行，Redis集群无须因此而停机。

集群模式有以下几个特点：

1.高可用。 Redis集群模式可为每个主节点配置副本节点，而且自带高可用功能，其机制和Sentinel类似，在主节点故障时自动实施故障转移。

2.高性能。 客户端发送的命令在绝大部分情况下都不需要实施转向，或者仅需要一次转向，因此在Redis集群中执行命令的性能与在单机Redis服务器上执行命令的性能非常接近，在海量数据的情况下Redis集群模式比Redis单机模式性能大幅度领先。

3.可扩展。 Redis集群通过槽机制让数据均匀分布或者根据权重分布在所有的节点上，在需要扩展时可以很方便的添加新的Redis实例，甚至不需要重启集群。

二、集群模式部署

接下来部署有十个Redis节点，包含五主五从的Redis集群，端口号设置从30001到30010。其架构图如下所示：

先创建10个文件夹，编号从30001到30010，然后将redis-server以及redis.conf文件挨个复制进去（redis编译参考：《CentOS安装Redis》），目录结构如下所示：

├── 30001
│   ├── redis.conf
│   └── redis-server
├── 30002
│   ├── redis.conf
│   └── redis-server
├── 30003
│   ├── redis.conf
│   └── redis-server
......
├── 30009
│   ├── redis.conf
│   └── redis-server
└── 30010
    ├── redis.conf
    └── redis-server

1、配置文件修改

修改每个节点的redis.conf文件：

port 30001  #修改该配置为正确的端口号，从30001到30010
daemonize yes #后台运行
logfile "server.log" #日志文件
dir "./" #工作目录设置在当前目录，即运行命令的目录，方便查看日志等
cluster-enabled yes  #开启集群功能
cluster-config-file nodes-30001.conf #集群运行时配置文件，会自动创建

2、运行10个Redis服务

进入每个文件夹，使用命令./redis-server ./redis.conf运行服务。

10个服务都启动起来之后，它们相互之间不知道彼此的存在，只是单纯的redis服务，并没有组成集群，此时要使用redis-cli工具创建集群让它们彼此关联起来。

3、创建集群

使用redis-cli运行如下命令创建集群：

./redis-cli --cluster create \  #创建集群命令
127.0.0.1:30001 127.0.0.1:30002 127.0.0.1:30003 127.0.0.1:30004 127.0.0.1:30005 127.0.0.1:30006 127.0.0.1:30007 127.0.0.1:30008 127.0.0.1:30009 127.0.0.1:30010 \ #指定10个节点的ip和端口号
--cluster-replicas 1  #每个主节点1个副本

运行完会提示如下信息：

>>> Performing hash slots allocation on 10 nodes...
Master[0] -> Slots 0 - 3276
Master[1] -> Slots 3277 - 6553
Master[2] -> Slots 6554 - 9829
Master[3] -> Slots 9830 - 13106
Master[4] -> Slots 13107 - 16383
Adding replica 127.0.0.1:30007 to 127.0.0.1:30001
Adding replica 127.0.0.1:30008 to 127.0.0.1:30002
Adding replica 127.0.0.1:30009 to 127.0.0.1:30003
Adding replica 127.0.0.1:30010 to 127.0.0.1:30004
Adding replica 127.0.0.1:30006 to 127.0.0.1:30005
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: d85dc362370f81fe627305e9b246365bd51a02c2 127.0.0.1:30001
   slots:[0-3276] (3277 slots) master
M: 9d148120512f85f29dd246e515243fd6019c7dcc 127.0.0.1:30002
   slots:[3277-6553] (3277 slots) master
M: d5f1adb8939529abcfe24e657bd01787b7d7928c 127.0.0.1:30003
   slots:[6554-9829] (3276 slots) master
M: 6d2c221d2ff15ae7fb9d5a5b7551ae5b493e791f 127.0.0.1:30004
   slots:[9830-13106] (3277 slots) master
M: adbbff5339b083b1e4fb641951e6fb9085ffb25c 127.0.0.1:30005
   slots:[13107-16383] (3277 slots) master
S: c33e236a553d9e658a0bb549d933567de5a756f8 127.0.0.1:30006
   replicates 9d148120512f85f29dd246e515243fd6019c7dcc
S: 1728a0fb708c776303f25e33c0add3297332cd64 127.0.0.1:30007
   replicates 6d2c221d2ff15ae7fb9d5a5b7551ae5b493e791f
S: dd7079d8486119fecc4e71f10fb705889ea8668b 127.0.0.1:30008
   replicates d85dc362370f81fe627305e9b246365bd51a02c2
S: 0db0c21f6f9b075b887c0ef1548cf35cb0505b0b 127.0.0.1:30009
   replicates adbbff5339b083b1e4fb641951e6fb9085ffb25c
S: 32661eb91b3be79b9a9d9ba873e1066bd64916a7 127.0.0.1:30010
   replicates d5f1adb8939529abcfe24e657bd01787b7d7928c
Can I set the above configuration? (type 'yes' to accept):

以上是一段提示性信息，提示我们将要进行集群创建了，有哪些节点是主节点，每个主节点将分配多少个槽，每个主节点的副本节点是谁，主节点的id和副本节点的id是什么。。可以说尽可能详尽的告诉我们如果创建了集群，它将会是什么样子的。输入yes表示同意按照这个配置创建集群：

Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
.
>>> Performing Cluster Check (using node 127.0.0.1:30001)
M: d85dc362370f81fe627305e9b246365bd51a02c2 127.0.0.1:30001
   slots:[0-3276] (3277 slots) master
   1 additional replica(s)
S: c33e236a553d9e658a0bb549d933567de5a756f8 127.0.0.1:30006
   slots: (0 slots) slave
   replicates 9d148120512f85f29dd246e515243fd6019c7dcc
S: 0db0c21f6f9b075b887c0ef1548cf35cb0505b0b 127.0.0.1:30009
   slots: (0 slots) slave
   replicates adbbff5339b083b1e4fb641951e6fb9085ffb25c
S: 32661eb91b3be79b9a9d9ba873e1066bd64916a7 127.0.0.1:30010
   slots: (0 slots) slave
   replicates d5f1adb8939529abcfe24e657bd01787b7d7928c
S: 1728a0fb708c776303f25e33c0add3297332cd64 127.0.0.1:30007
   slots: (0 slots) slave
   replicates 6d2c221d2ff15ae7fb9d5a5b7551ae5b493e791f
M: adbbff5339b083b1e4fb641951e6fb9085ffb25c 127.0.0.1:30005
   slots:[13107-16383] (3277 slots) master
   1 additional replica(s)
S: dd7079d8486119fecc4e71f10fb705889ea8668b 127.0.0.1:30008
   slots: (0 slots) slave
   replicates d85dc362370f81fe627305e9b246365bd51a02c2
M: 6d2c221d2ff15ae7fb9d5a5b7551ae5b493e791f 127.0.0.1:30004
   slots:[9830-13106] (3277 slots) master
   1 additional replica(s)
M: d5f1adb8939529abcfe24e657bd01787b7d7928c 127.0.0.1:30003
   slots:[6554-9829] (3276 slots) master
   1 additional replica(s)
M: 9d148120512f85f29dd246e515243fd6019c7dcc 127.0.0.1:30002
   slots:[3277-6553] (3277 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...

这样就创建成功了。

4、集群验证

我们用redis-cli工具验证，运行如下命令进入集群中的30001节点：

./redis-cli -c -p 30001

注意-c参数的使用，表示是集群模式连接，如果没有这个参数，后续运行命令可能会报错。

运行命令

cluster info

查看输出：

cluster_state:ok				#集群状态正常
cluster_slots_assigned:16384	#16384个槽均已分配
cluster_slots_ok:16384			#16384个槽状态都正常
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:10			#集群中有10个节点
cluster_size:5
cluster_current_epoch:10
cluster_my_epoch:1
cluster_stats_messages_ping_sent:13777
cluster_stats_messages_pong_sent:13518
cluster_stats_messages_fail_sent:12
cluster_stats_messages_sent:27307
cluster_stats_messages_ping_received:13518
cluster_stats_messages_pong_received:13767
cluster_stats_messages_fail_received:6
cluster_stats_messages_received:27291

从输出信息上来看，集群状态是正常的。

接下来运行如下命令查看所有节点信息：

cluster nodes

运行结果如下：

从输出上来看，5主5从10个节点都是正常的。还能看到一些主从关系信息，比如30010是30003的副本节点。

当然，可以运行如下命令确认一下：

CLUSTER REPLICAS d5f1adb8939529abcfe24e657bd01787b7d7928c

输出如下：

可以看到30010确实是30003的副本节点。

接下来看看其高可用机制是否生效，我们把30003主节点下掉，看看30010是否会成为主节点实现自动故障转移。

使用命令./redis-cli -p 30003 进入30003节点，运行命令shutdown退出reids进程，之后查看30003的副本节点30010的日志：

从节点日志上来看，30010副本节点发现无法联系上30003主节点之后，发起了一次投票选举主节点，最后自己成为了新的主节点。

重新运行cluster nodes命令：

可以看到30003节点已经被标记为下线状态，30010副本节点已经被提级为主节点了。

接下来再把30003节点启动起来，看看能否自动加入集群。

先看下其启动日志：

从启动日志上来看，30003节点启动之后把自己变成了30010的副本，并且发起了一次全量数据同步，30003节点应该变成了30010的副本。运行命令cluster nodes命令查看：

可以看到重新启动起来的30003节点变成了30010的副本节点，这个和sentinel+主从复制模式中的处理策略是相同的。

至此，我们验证了集群已经成功搭建完成。

三、集群管理命令

与sentinel模式相似，cluster模式也有一套管理命令，使用./redis-cli -c -p 30001进入集群任意一节点以后，使用命令cluster help可以查看所有相关的命令：

127.0.0.1:30001> cluster help
 1) CLUSTER <subcommand> [<arg> [value] [opt] ...]. Subcommands are:
 2) ADDSLOTS <slot> [<slot> ...]
 3)     Assign slots to current node.
 4) BUMPEPOCH
 5)     Advance the cluster config epoch.
 6) COUNT-FAILURE-REPORTS <node-id>
 7)     Return number of failure reports for <node-id>.
 8) COUNTKEYSINSLOT <slot>
 9)     Return the number of keys in <slot>.
10) DELSLOTS <slot> [<slot> ...]
11)     Delete slots information from current node.
12) FAILOVER [FORCE|TAKEOVER]
13)     Promote current replica node to being a master.
14) FORGET <node-id>
15)     Remove a node from the cluster.
16) GETKEYSINSLOT <slot> <count>
17)     Return key names stored by current node in a slot.
18) FLUSHSLOTS
19)     Delete current node own slots information.
20) INFO
21)     Return information about the cluster.
22) KEYSLOT <key>
23)     Return the hash slot for <key>.
24) MEET <ip> <port> [<bus-port>]
25)     Connect nodes into a working cluster.
26) MYID
27)     Return the node id.
28) NODES
29)     Return cluster configuration seen by node. Output format:
30)     <id> <ip:port> <flags> <master> <pings> <pongs> <epoch> <link> <slot> ...
31) REPLICATE <node-id>
32)     Configure current node as replica to <node-id>.
33) RESET [HARD|SOFT]
34)     Reset current node (default: soft).
35) SET-CONFIG-EPOCH <epoch>
36)     Set config epoch of current node.
37) SETSLOT <slot> (IMPORTING|MIGRATING|STABLE|NODE <node-id>)
38)     Set slot state.
39) REPLICAS <node-id>
40)     Return <node-id> replicas.
41) SAVECONFIG
42)     Force saving cluster configuration on disk.
43) SLOTS
44)     Return information about slots range mappings. Each range is made of:
45)     start, end, master and replicas IP addresses, ports and ids
46) HELP
47)     Prints this help.

差不多有20来个命令。下面逐一介绍各个命令。

cluster meet

cluster meet命令用于将某个节点加入到当前集群（运行redis-cli所在的节点所属的集群）中，其完整命令如下所示：

cluster meet <ip> <port> [<bus-port>]

ip和port是待加入集群的ip地址和端口号，bus-port则似乎第一次见：bus-port是节点的集群通信端口号，默认值是<port>+10000，比如待加入集群的节点端口号是30011，那么集群通信端口号就是30011+10000=40011。集群通信端口号不处理业务请求，仅用于集群内部通信，例如故障检测、配置更新、数据迁移等关键操作。

比如，我们在30001节点进入redis-cli，使用cluster meet命令加入一个新节点30011，将30011加入到集群中：

cluster meet 127.0.0.1 30011  #等价于 cluster meet 127.0.0.1 30011 40011

观察30011的日志：

2797:M 18 Jul 2025 18:20:51.333 # IP address for this node updated to 127.0.0.1
2797:M 18 Jul 2025 18:20:57.197 # Cluster state changed: ok

运行cluster nodes命令观察新加入的节点：

可以看到30011作为master节点已经加入到了集群中。

cluster nodes

该命令用于查看集群内所有节点的相关信息，其完整命令：

cluster nodes

返回值是一个列表，形式如下所示：

<id> <ip:port> <flags> <master> <pings> <pongs> <epoch> <link> <slot>

各个字段的意思如下所示：

字段	信息项	意义
`<id>`	节点ID	记录节点的运行ID。每个节点的运行ID在集群中都是唯一的，用户可以在执行集群操作时将其用作节点的标识符
`<ip:port>`	地址和端口	记录节点的IP地址以及端口号。位于@符号左边的是节点的客户端端口，而位于@符号右边的则是节点的集群端口，前者用于与客户端通信，而后者则用于与集群中的其他节点通信
`<flags>`	角色和状态	记录节点当前担任的角色以及节点目前所处的状态。表20-2记录了这个项可能出现的值，以及各个值代表的意思。当节点的角色和状态同时出现时，这个项会使用逗号去分隔多个值，比如显示myself,master表示这个节点是客户端目前正在连接的节点，并且它是一个主节点，而显示slave,fail?则表示这个节点是一个从节点，并且它正处于疑似下线状态
`<master>`	主节点ID	如果节点是一个从节点，那么这里显示的就是它正在复制的主节点的ID；如果节点本身就是一个主节点，那么它在这个项中只会显示一个-符号
`<pings>`	发送PING消息的时间	节点最近一次向其他节点发送PING消息时的UNIX时间戳，格式为毫秒。如果该节点与其他节点的连接正常，并且它发送的PING消息也没有被阻塞，那么这个值将被设置为0
`<pongs>`	收到PONG消息的时间	节点最近一次接收到其他节点发送的PONG消息时的UNIX时间戳，格式为毫秒。对于客户端正在连接的节点来说，这个项的值总是为0
`<epoch>`	配置纪元	节点所处的配置纪元
`<link>`	连接状态	节点集群总线的连接状态。connected表示连接正常，disconnected表示连接已断开
`<slot>`	负责的槽	显示节点目前负责处理的槽以及这些槽所处的状态。表20-3记录了这个项可能出现的值以及各个值代表的含义。如果节点是一个从节点，或者是一个没有负责任何槽的主节点，那么这一项的值将为空

节点的角色和状态

值	说明
myself	这是客户端目前正在连接的节点
master	这是一个主节点
slave	这是一个从节点
fail?	这个节点正处于疑似下线状态
fail	这个节点已经下线
nofailover	这个节点开启了 cluster-replica-no-failover 配置选项，带有这个标志的从节点即使在主服务器下线的情况下，也不会主动执行故障转移操作
handshake	集群正在与这个节点握手，尚未确认它的状态
noaddr	目前尚不清楚这个节点的具体地址
noflags	目前尚不清楚这个节点担任的角色以及它所处的状态

槽的数字以及状态

槽的类型	打印方式
连续的槽	每当CLUSTER NODES命令遇到连续的槽号时，它就会以`start_slot-end_slot`格式打印节点负责的槽。比如，打印`0-5460`代表节点负责从槽0直到槽5460在内的连续多个槽
不连续的槽	每当CLUSTER NODES命令遇到不连续的槽号时，就会单独地打印出不连续的槽号。比如，如果一个节点只负责了1、3、5这3个槽，那么命令在这个节点的槽号部分将打印出`1 3 5`。因为CLUSTER NODES总是会将节点负责的每一个不连续槽号都打印出来，所以如果一个节点负责了大量不连续的槽，那么它的槽号部分可能会非常庞大
正在导入的槽	如果节点正在从另一个节点导入某个槽，那么CLUSTER NODES命令将以`[slot_number-<-node_id]`的格式打印出被导入的槽以及该槽原来所在的节点。比如，打印`[123-<-47b7ea54965875c3bf1316071584e842342c6fa3]`就代表节点正在从ID为47b7ea54965875c3bf1316071584e842342c6fa3的节点中导入槽123
正在迁移的槽	如果节点正在将自己的某个槽迁移至另一个节点，那么CLUSTER NODES命令将以`[slot_number->-node_id]`格式打印出被迁移的槽以及该槽正在迁移的目标节点。比如，如果节点正在将自己的槽255迁移至ID为47b7ea54965875c3bf1316071584e842342c6fa3的节点，那么命令将打印出`[255->-47b7ea54965875c3bf1316071584e842342c6fa3]`

以我们新增的30011节点为例：

79a28e2df5e13dd726c892c42ee35a15423b00fb 127.0.0.1:30011@40011 master - 0 1752834070495 0 connected

节点id是79a28e2df5e13dd726c892c42ee35a15423b00fb
节点ip和端口号是127.0.0.1:30011，集群通信端口号是40011
节点角色是master
节点是master节点，没有master，以-表示
由于节点连接正常，pings是0
收到PONG消息的时间是1752834070495
配置纪元是0
连接状态是connected，表示连接正常
没有slots字段，因为这个节点是新加入集群的节点，还没有分配槽。

cluster myid

该命令用于查看当前节点的运行ID。因为不少集群命令都需要使用节点的运行ID作为参数，所以当我们需要对正在连接的节点执行某个使用运行ID作为参数的操作时，就可以使用CLUSTER MYID命令快速地获得节点的ID。

cluster info

该命令用于查看与集群以及当前节点有关的状态信息。

以下是一个对节点30001执行CLUSTER INFO命令的示例：

127.0.0.1:30001> cluster info
cluster_state:ok						#集群目前处于在线状态
cluster_slots_assigned:16384			#有16384个槽已经被指派
cluster_slots_ok:16384					#有16384个槽处于在线状态
cluster_slots_pfail:0					#没有槽处于疑似下线状态
cluster_slots_fail:0					#没有槽处于已下线状态
cluster_known_nodes:11					#集群包含11个节点
cluster_size:5							#集群中有5个节点被指派了槽
cluster_current_epoch:11				#集群当前所处的纪元为11				
cluster_my_epoch:1						#节点当前所处的配置纪元为1
cluster_stats_messages_ping_sent:25124	#节点发送PING消息的数量
cluster_stats_messages_pong_sent:24625	#节点发送PONG消息的数量
cluster_stats_messages_meet_sent:1		#节点发送的meet消息的数量
cluster_stats_messages_fail_sent:20		#表示当前节点向其他节点发送的FAIL消息数量为20次。FAIL消息用于通知集群其他节点某个节点已被标记为下线（故障状态）
cluster_stats_messages_auth-ack_sent:1		#表示节点发送的认证确认消息（AUTH-ACK）数量为1次。这类消息用于集群节点间的身份验证响应，通常在安全认证场景中出现
cluster_stats_messages_sent:49771			#当前节点通过集群总线（node-to-node二进制总线）发送的所有消息总量，包括PING、PONG、FAIL等各类消息
cluster_stats_messages_ping_received:24625	#节点接收到的PING消息数量
cluster_stats_messages_pong_received:25114	#节点接收到的PONG消息数量
cluster_stats_messages_fail_received:7		#节点接收到的FAIL消息数量，表示其他节点通知本节点有7次关于某个节点故障的广播
cluster_stats_messages_auth-req_received:1 #节点接收到的认证请求消息（AUTH-REQ）数量，通常用于集群安全认证的初始化
cluster_stats_messages_received:49747      #节点通过集群总线接收的所有消息总量

从输出上来看，可以总结出来关于message的重要特点：

cluster_stats_messages_<type>_received：表示某种类型消息接收的数量
cluster_stats_messages_<type>_sent：表示某种类型消息发送的数量

cluster forget

该命令用于从集群中移除某个节点，完整命令如下所示：

CLUSTER FORGET <node-id>

与CLUSTER MEET命令引发的节点添加消息不一样，CLUSTER FORGET命令引发的节点移除消息并不会通过Gossip协议传播至集群中的其他节点：当用户向一个节点发送CLUSTER FORGET命令，让它去移除集群中的另一个节点时，接收到命令的节点只是暂时屏蔽了用户指定的节点，但这个被屏蔽的节点对于集群中的其他节点仍然是可见的。为此，要让集群真正地移除一个节点，用户必须向集群中的所有节点都发送相同的CLUSTER FORGET命令，并且这一动作必须在60s之内完成，否则被暂时屏蔽的节点就会因为Gossip协议的作用而被重新添加到集群中。

可以使用redis-cli工具对集群中所有节点发送相同的命令移除刚新增的30011节点：

./redis-cli --cluster call 127.0.0.1:30001 cluster forget 79a28e2df5e13dd726c892c42ee35a15423b00fb

cluster replicate

该命令用于将执行命令的当前节点转换为某个主节点的从节点，完整命令如下所示：

cluster replicate <node-id>

用户给定的主节点必须与当前节点位于相同的集群当中。此外，根据当前节点角色的不同，CLUSTER REPLICATE命令在执行时的情况也会有所不同：

如果当前节点是一个主节点，那么它必须是一个没有被指派任何槽的主节点，并且它的数据库中也不能有任何数据，这样它才可以转换成一个从节点。
如果当前节点已经是一个从节点，那么它将清空数据库中已有的数据，并开始复制用户给定的节点。

CLUSTER REPLICATE命令在成功执行时将返回OK作为结果。与单机版本的REPLICAOF命令一样，CLUSTER REPLICATE命令引发的复制操作也是异步执行的。

需要注意的是，该命令和单机版本的replicaof不同，在使用单机版本的Redis时，用户可以让一个从服务器去复制另一个从服务器，以此来构建一系列链式复制的服务器；而Redis集群只允许节点对主节点而不是从节点进行复制，如果用户尝试使用CLUSTER REPLICATE命令让一个节点去复制一个从节点，那么命令将返回一个错误：

cluster replicas

该命令用于查询某个节点的所有从节点的信息，其完整命令如下所示：

cluster replicas <node-id>

该命令的输出可以认为是cluster nodes命令的一部分，其输出表头是一样的。

cluster failover

该命令作用对象是从节点，用于对从节点强制故障转移，将从节点提升为主节点，其完整命令如下：

cluster failover [force|takeover]

默认情况下，CLUSTER FAILOVER执行安全的主从切换，流程包括

Slave通知Master停止处理客户端请求。
Master返回当前复制偏移量（replication offset）。
Slave等待数据同步完成后再晋升为Master。
新配置需获得集群中半数以上Master的投票认可

使用force和takeover可改变这个过程以适应不同情况下的集群恢复：

force：当Master宕机无法响应Slave的协商请求，但集群中半数以上Master仍存活时使用；跳过与旧Master的数据同步协商（即跳过标准流程的前3步），直接发起选举，但仍需获得多数Master的投票认可才能晋升；在Master不可达但集群仍健康时加速切换，避免因等待超时而延长服务中断时间
takeover：当半数以上Master节点故障（如机房断网），集群无法达成多数投票时使用；完全绕过选举机制，Slave直接生成最大的config epoch，强制接管所有Slot并广播新配置。其他节点收到后会无条件接受新主节点；可能导致配置冲突（如脑裂），仅用于极端故障恢复（如多活机房容灾）或测试环境。

cluster reset

该命令用于重置节点，完整命令如下所示：

cluster reset [hard|soft]

这个命令接受SOFT和HARD两个可选项作为参数，用于指定重置操作的具体行为（软重置和硬重置）。如果用户在执行CLUSTER RESET命令的时候没有显式地指定重置方式，那么命令默认将使用SOFT选项。

CLUSTER RESET命令在执行时，将对节点执行以下操作：

遗忘该节点已知的其他所有节点。
撤销指派给该节点的所有槽，并清空节点内部的槽-节点映射表。
如果执行该命令的节点是一个从节点，那么将它转换成一个主节点。
如果执行的是硬重置，那么为节点创建一个新的运行ID。
如果执行的是硬重置，那么将节点的纪元和配置纪元都设置为0。
通过集群节点配置文件的方式，将新的配置持久化到硬盘上。

需要注意的是，执行该命令的节点不能有数据，如果节点的数据库非空，那么该命令将执行失败。

cluster slots

该命令用于查看槽与节点之间的关联信息，完整命令如下所示：

cluster slots

命令会返回一个嵌套数组，数组中的每个项记录了一个槽范围（slot range）及其处理者的相关信息，其中包括

槽范围的起始槽。
槽范围的结束槽。
负责处理这些槽的主节点信息。
零个或任意多个主节点属下从节点的信息。

其中，每一项节点信息都由以下3项信息组成：

节点的IP地址。
节点的端口号。
节点的运行ID。

比如以下输出结果：

127.0.0.1:30001> CLUSTER SLOTS
1) 1) (integer) 6554			#起始槽
   2) (integer) 9829			#结束槽
   3) 1) "127.0.0.1"			#主节点ip地址
      2) (integer) 30010		#主节点端口号
      3) "32661eb91b3be79b9a9d9ba873e1066bd64916a7" #主节点id
   4) 1) "127.0.0.1"			#从节点ip地址
      2) (integer) 30003		#从节点端口号
      3) "d5f1adb8939529abcfe24e657bd01787b7d7928c" #从节点id
......

cluster keyslot

该命令用于查看键所属的槽，完整命令如下：

cluster keyslot <key>

比如30001节点有key f，想知道f存储在哪个槽了，可以使用该命令查询：

cluster addslots

该命令用于把指定的槽分配给当前节点，完整命令如下所示：

cluster addslots <slot> [<slot> ...]

需要注意的是，CLUSTER ADDSLOTS只能对尚未被指派的槽执行指派操作，如果用户给定的槽已经被指派，那么命令将报错：

cluster delslots

该命令用于撤销当前节点的槽指派，完整命令如下所示：

cluster delslots <slot> [<slot> ...]

比如，我们想要撤销30001节点的3168槽，可以使用如下命令：

cluster delslots 3168

运行cluster info命令，可以看到集群状态为失败状态，而且槽指派的数量本应是16384，现在是16383，减少了1

可以使用cluster slots查看槽分配的详情。

需要注意的是，使用 CLUSTER DELSLOTS 命令删除槽指派后，对应槽中的数据不会立即被清除，但会变为不可访问状态。使用get命令获取key会提示如下信息：

如何恢复数据呢？

有两种情况，一是槽直接分配给原节点，这种情况可以使用cluster addslots命令将槽分配下就可以了；另外一种情况是槽要迁移到别的节点上，这种情况需要使用cluster setslots命令做槽迁移。

先用cluster addslots尝试在原节点恢复槽分配：

正常获取到了f的key值，可以确定30001的3168槽已经恢复槽分配。

cluster setslot

该命令可以改变给定槽在节点中的状态，从而实现节点之间的槽迁移以及集群重分片。该命令完整格式如下所示：

cluster setslot <slot> (IMPORTING|MIGRATING|STABLE|NODE <node-id>)

该命令有四个子命令，通过四个命令的相互搭配，可以实现不同节点之间的槽迁移。我们接下来将30001（id为d85dc362370f81fe627305e9b246365bd51a02c2）节点上的3168槽迁移到30002（id为9d148120512f85f29dd246e515243fd6019c7dcc）节点上，看看如何操作。

在正式操作前，需要确保3168槽归30001节点所有，这点和addslots命令的要求完全相反的。

第一步：30001节点设置为MIGRATING状态

运行命令：

127.0.0.1:30001> cluster setslot 3168 MIGRATING d85dc362370f81fe627305e9b246365bd51a02c2
OK

运行完晒命令，30001节点将自己状态设置为“迁移中”状态，准备发送3168槽的数据。

第二步：30002节点设置为IMPORTING状态

运行命令：

127.0.0.1:30002> cluster setslot 3168 IMPORTING 9d148120512f85f29dd246e515243fd6019c7dcc
OK

运行命令后，节点30002的状态被设置为“导入中”状态，准备接收3168槽的数据。

第三步：key迁移

获取3168槽中的key：

127.0.0.1:30001> CLUSTER GETKEYSINSLOT 3168 10
1) "f"
127.0.0.1:30001>

可以看到只有一个key。

然后使用migrate命令将key迁移到30002节点：

127.0.0.1:30001> migrate 127.0.0.1 30002 "" 0 3000 keys f
OK
127.0.0.1:30001>

第四步：将槽指派给节点

迁移完成数据以后，在集群中任意节点将3168槽指派给30002节点。

cluster setslot 3168 node 9d148120512f85f29dd246e515243fd6019c7dcc

集群的其中一个节点在执行了NODE子命令之后，对给定槽的新指派信息将被传播至整个集群，目标节点在接收到这一信息之后将移除给定槽的“导入中”状态，而源节点在接收到这一信息之后将移除给定槽的“迁移中”状态。

30001节点再次查询f的键值，将会重定向到30002节点：

127.0.0.1:30001> get f
-> Redirected to slot [3168] located at 127.0.0.1:30002
"6"
127.0.0.1:30002>

可以看到，使用cluster setslot命令迁移槽节点是比较麻烦的，为了精简这个步骤，可以使用cluster-cli的工具命令，一个命令就可以解决了：

./redis-cli --cluster reshard 127.0.0.1:30002 --cluster-from 9d148120512f85f29dd246e515243fd6019c7dcc --cluster-to d85dc362370f81fe627305e9b246365bd51a02c2 --cluster-slots 1

该命令的确定是不能精准控制哪几个槽的迁移，只能确定迁移的数量。部分输出如下：

可以看到挑选需要迁移的节点也可能是有策略的，并没有破坏了其它连续的槽节点，而是挑选了单独的3168槽迁移。

关于redis-cli工具的具体使用，后续会有介绍。

cluster keyslot

该命令用于查看键所属的槽，完整命令如下所示：

cluster keyslot <key>

比如我们想查看f键所属的槽，可以运行如下命令：

127.0.0.1:30001> CLUSTER KEYSLOT f
(integer) 3168
127.0.0.1:30001>

cluster countkeysinslot

该命令用于查询槽包含的键数量，完整命令如下所示：

cluster countkeysinslot <slot>

举例，我们想查看3168槽中包含的键数量，可以使用如下命令：

127.0.0.1:30002> cluster countkeysinslot 3168
(integer) 1
127.0.0.1:30002>

注意运行该命令必须在3168槽所属的节点上运行，否则会返回0。

cluster getkeysinslot

该命令用于获取槽包含的键，完整命令如下所示：

cluster getkeysinslot <slot> <count>

比如我想从3168槽中获取10条数据，可以运行如下命令：

127.0.0.1:30002> cluster getkeysinslot 3168 10
1) "f"
127.0.0.1:30002>

注意该命令必须在3168槽所属的节点上运行，否则查询不到数据。

cluster flushslots

该命令用于撤销对节点的所有槽指派，相当于对节点上的每个槽执行cluster delslots命令。完整命令如下所示：

cluster flushslots

用户在执行CLUSTER FLUSHSLOTS命令之前，必须确保节点的数据库为空，否则节点将拒绝执行命令并返回一个错误。

127.0.0.1:30002> cluster flushslots
(error) ERR DB must be empty to perform CLUSTER FLUSHSLOTS.

四、注意事项

1、集群模式对部分命令的影响

由于集群模式比较特殊，每个节点分管部分槽，这导致每个节点都不知道全部节点的key都是什么，所以使用keys命令只能查看自己节点的键。

127.0.0.1:30001> set a 1
-> Redirected to slot [15495] located at 127.0.0.1:30005
OK
127.0.0.1:30005> set b 2
-> Redirected to slot [3300] located at 127.0.0.1:30002
OK
127.0.0.1:30002> set c 3
-> Redirected to slot [7365] located at 127.0.0.1:30010
OK
127.0.0.1:30010> set f 4
-> Redirected to slot [3168] located at 127.0.0.1:30001
OK
127.0.0.1:30001> keys *
1) "f"
127.0.0.1:30001>

同样的，cluster countkeysinslot以及cluster getkeysinslot 命令都有类似的问题，需要注意。

2、强制键放在同槽的方法

在默认情况下，Redis将根据用户输入的整个键计算出该键所属的槽，然后将键存储到相应的槽中，但是有些时候，需要将键放到同一个槽中，这时候可以使用散列标签实现该功能。

散列标签功能会找出键中第一个被大括号{}包围并且非空的字符串子串（sub string），然后根据子串计算出该键所属的槽。这样一来，即使两个键原本不属于同一个槽，但只要它们拥有相同的被包围子串，那么程序计算出的散列值就是一样的，因此Redis集群就会把它们存储到同一个槽中。

举个例子，默认情况下我们存储user:1以及user:2结果如下所示：

127.0.0.1:30001> set user:1 1
-> Redirected to slot [10778] located at 127.0.0.1:30004
OK
127.0.0.1:30004> set user:2 2
-> Redirected to slot [6777] located at 127.0.0.1:30010
OK

可以看到两个键被分别存储到了3004节点以及30010节点上不同的槽。

但是如果使用散列标签方式，可以让user开头的key都存到同一个槽中：

127.0.0.1:30010> set {user}:1 1
-> Redirected to slot [5474] located at 127.0.0.1:30002
OK
127.0.0.1:30002> set {user}:2 2
OK
127.0.0.1:30002> cluster getkeysinslot 5474 10
1) "{user}:1"
2) "{user}:2"

可以看到两个键都被存到了30002节点上的5474槽位。

END.

Redis（八）：多机部署之Sentinel（哨兵）模式

Tue, 15 Jul 2025 22:49:12 +0800

在上一篇文章《Redis（七）：多机部署之主从复制模式》中讲过在主从复制模式下从节点发生了故障之后重连数据重新同步的问题，但是并没有提过主节点发生了故障会发生什么。实际上从节点挂掉并不会影响什么，但是主节点挂掉影响就大了，如果没有高可用机制，则需要人工干预手动选择其他节点作为主节点，整个过程从发现到处理结束不仅耗时处理还繁琐。如何让这个过程自动化呢？这就是本篇文章讨论的主题：基于Redis6.2.1使用sentinel实现Redis主从复制模式高可用。

一、手动处理主节点故障

主从服务器拥有相同的数据，所以它们在理论上是可以互相替换的：如果我们把主服务器的某个从服务器转换为主服务器，让它代替原来的主服务器处理命令请求，那么它得出的结果应该与原来的主服务器处理相同请求时得出的结果一致。基于这个原理，我们可以在主服务器因故下线时，将它的其中一个从服务器转换为主服务器，并使用新的主服务器继续处理命令请求，这样整个系统就可以继续运转，不必仅因为主服务器的下线而停机。这种使用正常服务器替换下线服务器以维持系统正常运转的操作，一般被称为故障转移（failover）

因为Redis支持主从复制特性，所以我们同样可以对下线的Redis主服务器实施故障转移。举个例子，假设现在有一个主服务器127.0.0.1：6379（简称6379），它有两个从服务器127.0.0.1：6380（简称6380）和127.0.0.1：6381（简称6381），这3个服务器分别处理一些客户端的命令请求。如果在某一时刻，主服务器6379因为故障而下线，那么我们可以向6380发送命令REPLICAOF no one，将它转换为主服务器，然后向另一个从服务器6381发送命令REPLICAOF 127.0.0.6380，让它去复制新的主服务器6380，这样就可以重新建立起一个能够正常运作的主从服务器连接，并继续处理客户端发送的命令请求。

简单来说，如果我们在前面的例子中，使用了Redis sentinel来监视主服务器6379以及它的两个从服务器6380、6381，那么在6379因为故障而下线时，Redis sentinel就会把6380和6381的其中一个转换为主服务器，并让另一个从服务器去复制新的主服务器，这个过程完全不需要人工介入。

二、部署主从复制+sentinel

组建sentinel网络的方法非常简单，与启动单个sentinel时的方法一样：用户只需要启动多个sentinel，并使用sentinel monitor配置选项指定sentinel要监视的主服务器，那些监视相同主服务器的sentinel就会自动发现对方，并组成相应的sentinel网络。

在启动sentinel之前，我们先把主从复制模式的一主两从启动起来，详情可看文章《Redis（七）：多机部署之主从复制模式》部署完成之后的架构图：

接下来在同一台机器上启动三个sentinel实例。

源码构建redis（参考CentOS安装Redis）后，sentinel的程序文件和redis-server同一个文件夹，文件名为redis-sentinel，配置文件则和redis.conf文件夹同一个目录，文件名为sentinel.conf：

redis-6.2.1
	│
    ├── redis.conf
    ├── sentinel.conf
    └── src
        ├── redis-server
        └── redis-sentinel

之后创建三个文件夹sentinel.1、sentinel.2、sentinel.3分别将redis-sentinel、sentinel.conf文件复制进去，目录结构最终如下所示：

├── sentinel.1
│   ├── redis-sentinel
│   └── sentinel.conf
├── sentinel.2
│   ├── redis-sentinel
│   └── sentinel.conf
└── sentinel.3
    ├── redis-sentinel
    └── sentinel.conf

我们的目标架构如下：

1、配置文件修改

启动sentinel的命令是./redis-sentinel ./sentinel.conf，形式和redis-server的启动方式很像。sentinel的配置文件很重要，sentinel程序不仅读，而且还写该配置文件，所以在运行sentinel程序的时候一定要确保当前用户对该文件拥有写权限。下面说下配置文件的重要配置：

port 26379 #默认端口号26379，运行多个实例需要改动端口号
daemonize no #是否在后台运行
pidfile /var/run/redis-sentinel.pid #后台运行时创建的pid文件名
logfile ""  #日志文件的名称
dir /tmp #工作目录，最好是./这样可以方便查看日志文件
sentinel monitor mymaster 127.0.0.1 6379 2 #最重要的配置文件，监听的主服务器名称、ip、端口号以及quorum
sentinel down-after-milliseconds mymaster 30000  #多少毫秒内主服务器无响应考虑其主观下线

配置文件中最重要的配置就是sentinel monitor mymaster 127.0.0.1 6379 2，其中最后的2是quorum，当认为主节点主观下线的哨兵数量到达quorum的时候，就会执行故障转移操作。

修改配置文件成如下所示：

bind 0.0.0.0
port 26379  #另外两个sentinel实例修改为26380
daemonize yes
pidfile /var/run/redis-sentinel1.pid #另外两个sentinel实例修改成redis-sentinel2.pid、redis-sentinel3.pid
logfile "sentinel.log"
dir ./

另外两个配置：

sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000

则不需要动，特别注意此处为主服务器命名"mymaster"，在配置文件中有多处配置都使用了该名字，如果修改改名字，一定要全改掉。

2、启动sentinel

修改完配置文件以后，在三个文件夹中依次运行命令：

./redis-sentinel ./sentinel.conf

启动后查看26379日志：

2561:X 15 Jul 2025 13:26:06.421 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
2561:X 15 Jul 2025 13:26:06.422 # Redis version=6.2.1, bits=64, commit=00000000, modified=0, pid=2561, just started
2561:X 15 Jul 2025 13:26:06.422 # Configuration loaded
2561:X 15 Jul 2025 13:26:06.422 * Increased maximum number of open files to 10032 (it was originally set to 1024).
2561:X 15 Jul 2025 13:26:06.422 * monotonic clock: POSIX clock_gettime
2561:X 15 Jul 2025 13:26:06.423 * Running mode=sentinel, port=26379.
2561:X 15 Jul 2025 13:26:06.423 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
2561:X 15 Jul 2025 13:26:06.423 # Sentinel ID is 3a03b019736dfe3fe57e78863b8039d2c84b7a3a
2561:X 15 Jul 2025 13:26:06.423 # +monitor master mymaster 127.0.0.1 6379 quorum 2
2561:X 15 Jul 2025 13:30:37.763 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ mymaster 127.0.0.1 6379
2561:X 15 Jul 2025 13:30:37.764 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ mymaster 127.0.0.1 6379

之后26380和26381逐个启动起来之后，26379会打印日志：

2561:X 15 Jul 2025 13:39:23.767 * +sentinel sentinel 928560c4df01bf5b19ad19751fbeae80db947c18 127.0.0.1 26380 @ mymaster 127.0.0.1 6379
2561:X 15 Jul 2025 13:40:36.276 * +sentinel sentinel 9a84c1618c95ae74ed8000efee50be6a7bd4a73c 127.0.0.1 26381 @ mymaster 127.0.0.1 6379

这样即表示sentinel集群已经正确监控redis的master节点以及两个slave节点。现在我们有了三个sentinel实例以及一主两从三个redis实例，架构图如下所示：

3、部署验证

先使用命令

ps -aux | grep redis

查看三个sentinel和三个redis实例进程是否都在线：

没问题的话我们进行一个实验：突然把master干掉，看看sentinel会怎么做。

第一步：打开三个窗口，使用tail -f -n 200 sentinel.log命令实时查看日志

第二步：使用kill 1795杀掉redis master实例的进程

查看三个sentinel实例的日志（可能得等待几秒钟才能看到日志）：

sentinel1的日志：

sentinel2的日志：

sentinel3的日志：

从日志中可以看到（日志详解参考附录部分），哨兵最终选举了sentinel3作为执行者执行了故障转移，6381被选择成为新的主节点，原来的6379被标记为主观下线了。

使用redis-cli进入6381redis实例，查看其角色信息：

127.0.0.1:6381> role
1) "master"
2) (integer) 2655664
3) 1) 1) "127.0.0.1"
      2) "6380"
      3) "2655664"

可以看到，6381节点已经变成了master节点，而且它只有一个副本。

接下来我们将6379重新上线，看看sentinel做了什么：

三个sentinel实例打印了如下日志：

2561:X 15 Jul 2025 15:20:42.236 # -sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ mymaster 127.0.0.1 6381

表示消除了6379的主观下线状态，sentinel实例多了一行日志：

2561:X 15 Jul 2025 15:20:52.245 * +convert-to-slave slave 127.0.0.1:6379 127.0.0.1 6379 @ mymaster 127.0.0.1 6381

这表示将6379变成6381实例的副本。

再次进入6381 redis-cli，查看角色信息：

127.0.0.1:6381> role
1) "master"
2) (integer) 2729754
3) 1) 1) "127.0.0.1"
      2) "6380"
      3) "2729621"
   2) 1) "127.0.0.1"
      2) "6379"
      3) "2729754"

可以看到6379确实已经成为了6381的副本。

至此，我们验证了sentinel确实发挥了作用。

三、sentinel故障转移原理

我们的哨兵网络中有三个哨兵实例，每个实例都会独立检测除了自己之外的所有实例，包括redis实例以及sentinel实例，一旦主节点下线，每个哨兵都会发现，然后将其标记为“主观下线”，表示当前哨兵认为主节点不可用，同时通知其它哨兵。当认为主节点主观下线状态的哨兵数量大于配置的quorum时，会将该主节点标记为“客观下线”。这时，将开始正式的故障转移流程。

由于哨兵节点有多个，不可能都去执行故障转移操作，它们会先选举出来一个代表，具体的操作就是每个哨兵节点都从所有哨兵节点中投票选举一个，票多者成为leader，成为leader的哨兵将具体执行故障转移。

成为leader的哨兵先从所有的slave节点中选择合适的节点向其发送slaveof no one命令，使其成为主节点；之后重新设置其它节点，让其它节点成为该主节点的从节点（包括已下线的原主节点）。

最后，所有哨兵更新主节点和从节点信息，完成故障转移流程。

我们着重看下这个流程中的选举哨兵leader以及选举新的master节点的细节。

1、选举哨兵leader

Redis哨兵模式中的Leader选举是一个基于Raft算法的分布式一致性过程，用于在主节点故障时选举出一个负责协调故障转移的哨兵领导者。

哨兵Leader选举的触发条件是主节点被确认为**客观下线(ODown)**状态。这需要先经过：

主观下线(SDown)：单个哨兵通过心跳检测(PING命令)发现主节点无响应，该哨兵将主节点状态标记为主观下线。
客观下线(ODown)：当quorum数量的哨兵(通常为多数)都认为主节点不可用，达成共识，所有哨兵将该节点状态标记为客观下线。

选举采用了Raft算法，其核心要点包括：

**纪元(epoch)**机制：类似于Raft的term概念，每次选举会递增epoch值，确保选举过程有序
先到先得原则：最先发起投票请求的哨兵有更大几率成为Leader
多数决原则：候选人需要获得超过半数的哨兵投票才能当选

哨兵确认主节点ODown后，将自己的current_epoch加1，然后将leader字段指向自己，表明要参与竞选；随后向其他所有哨兵发送sentinel is-master-down-by-addr命令，附带自己的epoch和runID。**每个哨兵节点只能投一票，遵循"先到先投"原则。**收到请求的哨兵会比较请求中的epoch与自己的current_epoch：

如果请求epoch更大，则更新自己的epoch并将票投给请求方
如果epoch相同，则投给自己已记录的leader(可能是自己)

已投过票的哨兵会拒绝后续请求。

最终，得票最多的哨兵将成为leader。

在我们的例子中，有三个哨兵节点实例：

sentinel1：3a03b019736dfe3fe57e78863b8039d2c84b7a3a
sentinel2：928560c4df01bf5b19ad19751fbeae80db947c18
sentinel3：9a84c1618c95ae74ed8000efee50be6a7bd4a73c

三个哨兵节点均发现了主节点主观下线的事实，然后将该消息传播给了其它哨兵节点。

哨兵1最先得到消息，但是并没有得到所有消息，它只知道包括自己在内，有两个哨兵已经发现主节点主观下线了，并且触达了quorum阈值，主节点已经达到了客观下线的条件。所以它立即将纪元值自增1并发起投票，由于它觉得是自己发现主节点客观下线的，所以它将票投给了自己：

其实哨兵1不知道的是，哨兵3则知道3个哨兵的主节点主观下线状态了，所以哨兵3和哨兵1一样，都以为自己是第一个发现主节点客观下线的，所以它也将纪元新增1并且发起了投票，同样的，它将票投给了自己：

所以得胜票在哨兵2手里，哨兵2先收到谁的投票请求，它就会将票投给谁：

它将票投给了哨兵3，这意味着它先收到了节点3的投票请求，节点3顺利成章成为了哨兵leader。

2、选择新的主节点

选择新的主节点按照优先级 > offset > run id的次序依次筛选。

优先级最高的从节点胜出。每个redis数据节点都会在配置文件中有一个优先级配置（slave-priority，默认情况下都相同）
复制偏移量offset最大的从节点胜出。offset代表从节点从主节点这里同步数据的进度。数值越大，说明从节点的数据和主节点就越接近。
run id值更小的胜出。run id是每个redis节点启动的时候随机生成的一串数字（大小全凭缘分）。此时意味着优先级和offset都一样，那么选谁都可以，其实就是随便挑一个。

在我们的例子中，由于两个副本的优先级相同，有可能是6381的复制偏移量更大，也有可能是随机被选择到的，说不好是什么原因被选择到的。

四、sentinel管理命令

使用redis-cli可以像进入redis-server一样进入redis-sentinel执行各种命令，实际上sentinel的启动命令./redis-sentinel ./sentinel.conf可以替换为./redis-server ./sentinel.conf --sentinel，两者是等价的。

进入sentinel控制台命令：

./redis-cli -p 26379

进入控制台以后，能运行哪些命令呢？可以使用sentinel help命令查看有哪些子命令

127.0.0.1:26379> sentinel help
 1) SENTINEL <subcommand> [<arg> [value] [opt] ...]. Subcommands are:
 2) CKQUORUM <master-name>
 3)     Check if the current Sentinel configuration is able to reach the quorum
 4)     needed to failover a master and the majority needed to authorize the
 5)     failover.
 6) CONFIG SET <param> <value>
 7)     Set a global Sentinel configuration parameter.
 8) CONFIG GET <param>
 9)     Get global Sentinel configuration parameter.
10) GET-MASTER-ADDR-BY-NAME <master-name>
11)     Return the ip and port number of the master with that name.
12) FAILOVER <master-name>
13)     Manually failover a master node without asking for agreement from other
14)     Sentinels
15) FLUSHCONFIG
16)     Force Sentinel to rewrite its configuration on disk, including the current
17)     Sentinel state.
18) INFO-CACHE <master-name>
19)     Return last cached INFO output from masters and all its replicas.
20) IS-MASTER-DOWN-BY-ADDR <ip> <port> <current-epoch> <runid>
21)     Check if the master specified by ip:port is down from current Sentinel's
22)     point of view.
23) MASTER <master-name>
24)     Show the state and info of the specified master.
25) MASTERS
26)     Show a list of monitored masters and their state.
27) MONITOR <name> <ip> <port> <quorum>
28)     Start monitoring a new master with the specified name, ip, port and quorum.
29) MYID
30)     Return the ID of the Sentinel instance.
31) PENDING-SCRIPTS
32)     Get pending scripts information.
33) REMOVE <master-name>
34)     Remove master from Sentinel's monitor list.
35) REPLICAS <master-name>
36)     Show a list of replicas for this master and their state.
37) RESET <pattern>
38)     Reset masters for specific master name matching this pattern.
39) SENTINELS <master-name>
40)     Show a list of Sentinel instances for this master and their state.
41) SET <master-name> <option> <value>
42)     Set configuration paramters for certain masters.
43) SIMULATE-FAILURE (CRASH-AFTER-ELECTION|CRASH-AFTER-PROMOTION|HELP)
44)     Simulate a Sentinel crash.
45) HELP
46)     Prints this help.

sentinel masters

sentinel masters命令用于获取所有被监视主服务器的信息。从命令形式中就可以看出，实际上sentinel网络可以监控多个master实例，只需要在配置文件中配置好就可以。sentinel masters命令输出如下所示：

127.0.0.1:26379> sentinel masters
1)  1) "name"
    2) "mymaster"
    3) "ip"
    4) "127.0.0.1"
    5) "port"
    6) "6381"
    7) "runid"
    8) "a63914648545d8922778cc3a6bfcc5eefc383260"
    9) "flags"
   10) "master"
   11) "link-pending-commands"
   12) "0"
   13) "link-refcount"
   14) "1"
   15) "last-ping-sent"
   16) "0"
   17) "last-ok-ping-reply"
   18) "730"
   19) "last-ping-reply"
   20) "730"
   21) "down-after-milliseconds"
   22) "30000"
   23) "info-refresh"
   24) "6813"
   25) "role-reported"
   26) "master"
   27) "role-reported-time"
   28) "11141987"
   29) "config-epoch"
   30) "1"
   31) "num-slaves"
   32) "2"
   33) "num-other-sentinels"
   34) "2"
   35) "quorum"
   36) "2"
   37) "failover-timeout"
   38) "180000"
   39) "parallel-syncs"
   40) "1"

形成表格如下所示：

字段名	示例值	含义解释
`name`	`"mymaster"`	主服务器（master）的名称，由用户在 sentinel 配置中定义
`ip`	`"127.0.0.1"`	主服务器的 IP 地址。
`port`	`"6381"`	主服务器的端口号。
`runid`	`"a63914648545d..."`	主服务器的唯一运行 ID，用于标识实例
`flags`	`"master"`	当前角色标识，`master` 表示主节点；可能包含其他状态（如 `s_down`、`o_down`）
`link-pending-commands`	`"0"`	sentinel向服务器发送了命令之后，仍在等待回复的命令数量，通常为 0 表示无阻塞。
`link-refcount`	`"1"`	当前连接到主服务器的引用计数（如 sentinel 或客户端连接数）
`last-ping-sent`	`"0"`	距离 sentinel最后一次向服务器发送PING 命令之后消逝的毫秒数，0表示已发送
`last-ok-ping-reply`	`"730"`	服务器最后一次向sentinel 返回有效PING 命令回复之后消逝的毫秒数
`last-ping-reply`	`"730"`	服务器最后一次向 sentinel 返回 PING 命令回复之后消逝的毫秒数，一般与last-ok-ping-reply相同
`down-after-milliseconds`	`"30000"`	判定主节点不可用的超时时间（毫秒），超过此时间未响应则标记为主观下线（SDOWN）
`info-refresh`	`"6813"`	上一次从主节点获取 INFO 信息的时间间隔（毫秒）
`role-reported`	`"master"`	主节点自身报告的角色（应与 `flags` 一致）
`role-reported-time`	`"11141987"`	上一次角色报告的时间戳（毫秒）
`config-epoch`	`"1"`	配置版本号，用于故障转移时标识新主节点的唯一性
`num-slaves`	`"2"`	当前主节点的从服务器（slave）数量
`num-other-sentinels`	`"2"`	监控此主节点的其他 sentinel 实例数量（不包含当前 sentinel）
`quorum`	`"2"`	达成客观下线（ODOWN）所需的最小 sentinel 同意数
`failover-timeout`	`"180000"`	故障转移超时时间（毫秒），超过此时间未完成则放弃本次故障转移
`parallel-syncs`	`"1"`	故障转移后，允许同时向新主节点同步数据的从节点数量

sentinel master

该命令的完整格式如下：

sentinel master <master-name>

这个命令只会返回用户指定主服务器的相关信息。比如：

sentinel master mymaster

查询的是mymaster主服务器的相关信息。返回数据格式和sentinel masters相同。

sentinel sentinels

该命令用于获取其他sentinel的相关信息，其完整命令格式如下所示：

sentinel sentinels <master-name>

命令输出如下所示：

127.0.0.1:26379> sentinel sentinels mymaster
1)  1) "name"
    2) "928560c4df01bf5b19ad19751fbeae80db947c18"
    3) "ip"
    4) "127.0.0.1"
    5) "port"
    6) "26380"
    7) "runid"
    8) "928560c4df01bf5b19ad19751fbeae80db947c18"
    9) "flags"
   10) "sentinel"
   11) "link-pending-commands"
   12) "0"
   13) "link-refcount"
   14) "1"
   15) "last-ping-sent"
   16) "0"
   17) "last-ok-ping-reply"
   18) "813"
   19) "last-ping-reply"
   20) "813"
   21) "down-after-milliseconds"
   22) "30000"
   23) "last-hello-message"
   24) "145"
   25) "voted-leader"
   26) "?"
   27) "voted-leader-epoch"
   28) "1"

该输出和sentinel masters基本相同，有三项新增：

字段	解释
last-hello-message	距离当前 sentinel 最后一次从这个 sentinel那里收到问候信息之后，逝去的毫秒数
voted-leader	sentinel网络当前票选出来的sentinel首领(leader)，?表示目前无首领
voted-leader-epoch	sentinel首领当前所处的配置纪元

sentinel get-master-addr-by-name

该命令可以通过给定主服务器的名字来获取该服务器的IP地址以及端口号：

sentinel get-master-addr-by-name <master-name>

比如想获取mymaster节点的ip地址和端口号：

127.0.0.1:26379> sentinel GET-MASTER-ADDR-BY-NAME mymaster
1) "127.0.0.1"
2) "6381"

sentinel reset

sentinel reset命令可以让sentinel忘掉主服务器之前的记录，并重新开始对主服务器进行监视，其完整格式如下所示：

sentinel reset <pattern>

pattern可以使用通配符一次选定多个被监视的master节点。

sentinel reset命令我觉得是个最有用的命令了，sentinel会将运行中的数据实时写入sentinel.conf文件中，下次重启的时候会利用这些数据恢复上次运行时的状态，要命的是这时候往往很多节点的状态已经发生了变化，最主要的是有可能部分节点已经下线或者id已经发生了变化，这时候运行该命令可以让sentinel删除所有数据，重新开始对主服务器监视，相当于“关机重启”了。

运行该命令：

127.0.0.1:26379> sentinel reset mymaster
(integer) 1

sentinel日志：

运行了sentinel reset命令的哨兵节点会重新建立和其他哨兵的联系，并重新监视主节点，添加从节点。

sentinel failover

sentinel failover的作用是使用当前哨兵节点强制执行故障转移，其完整命令为：

sentinel failover <master-name>

一般来说，sentinel网络需要主节点故障之后触发故障转移流程，哨兵节点还需要先投票选举leader最后才能执行故障转移。使用sentinel failover命令则不需要主节点发生故障，也不需要选举，它将指定当前哨兵节点强制执行故障转移。

比如我们想使用sentinel1对mymaster实行强制故障转移，可以使用命令：

sentinel failover mymaster

sentinel1的日志：

可以看到，开启了新纪元2，并且6379服务重新变成了主节点。

sentinel ckquorum

sentinel ckquorum命令用于检查sentinel网络当前可用的sentinel数量是否达到了判断主服务器客观下线并实施故障转移所需的数量：

sentinel ckquorum <master-name>

举例：

127.0.0.1:26379> sentinel ckquorum mymaster
OK 3 usable sentinels. Quorum and failover authorization can be reached
127.0.0.1:26379>

从结果可以看到，sentinel网络目前有3个sentinel可用，这已经满足了判断mymaster客观下线所需的sentinel数量。

sentinel ckquorum命令一般用于检查sentinel网络的部署是否成功。比如，如果我们在部署了3个sentinel之后，却发现sentinel ckquorum只能识别到2个可用的sentinel，那就说明有什么地方出错了。

sentinel flushconfig

sentinel flushconfig命令用于将配置文件重新写入硬盘。

因为sentinel在被监视服务器的状态发生变化时就会自动重写配置文件，所以这个命令的作用就是在配置文件基于某些原因或错误而丢失时，立即生成一个新的配置文件。此外，当sentinel的配置选项发生变化时，sentinel内部也会使用这个命令创建新的配置文件来替换原有的配置文件。

这个命令在误删除配置文件的时候非常有用。

sentinel monitor

该命令用于监视一个新的主服务器，完整命令如下：

sentinel monitor <master-name> <ip> <port> <quorum>

sentinel monitor命令本质上就是sentinel monitor配置选项的命令版本，当我们想要让sentinel监视一个新的主服务器，但是又不想重启sentinel并手动修改sentinel配置文件时就可以使用这个命令。

比如，我们想监控127.0.0.1:6379主服务器，而且达成客观下线所需的最小 sentinel 同意数为2，则可以运行如下命令：

sentinel monitor mymaster 127.0.0.1 6379 2

sentinel remove

该命令用于取消对指定主服务器的监控，完整命令如下所示：

sentinel remove <masters-name>

接收到这个命令的sentinel会停止对给定主服务器的监视，并删除sentinel内部以及sentinel配置文件中与给定主服务器有关的所有信息，然后返回OK表示操作执行成功。

举例：移除对mymaster主节点的监控

sentinel remove mymaster

sentinel set

该命令用于在线修改sentinel配置文件中与主服务器相关的配置选项值，完整命令如下：

sentinel set <master-name> <option> <value>

只要是sentinel配置文件中与主服务器有关的配置选项，都可以使用sentinel set命令在线进行配置。命令在成功修改给定的配置选项值之后将返回OK作为结果。

可以先使用sentinel masters命令查看有哪些参数以及值是多少，然后使用该命令修改指定的参数值。

比如，我要修改failover-timeout的值，可以这样做：

sentinel set mymaster failover-timeout 120000

注意该修改并不会传播给其它哨兵节点，也就是说每个哨兵节点都需要执行一次这个命令才能实现配置同步。

sentinel myid

该命令用于查询当前哨兵节点的id号码

127.0.0.1:26379> sentinel myid
"3a03b019736dfe3fe57e78863b8039d2c84b7a3a"

sentinel replicas

该命令用于展示被监控的主节点的所有副本信息，完整命令如下所示：

sentinel replicas <master-name>

举例：

127.0.0.1:26379> sentinel replicas mymaster
1)  1) "name"
    2) "127.0.0.1:6381"
    3) "ip"
    4) "127.0.0.1"
    5) "port"
    6) "6381"
    7) "runid"
    8) "a63914648545d8922778cc3a6bfcc5eefc383260"
    9) "flags"
   10) "slave"
   11) "link-pending-commands"
   12) "0"
   13) "link-refcount"
   14) "1"
   15) "last-ping-sent"
   16) "0"
   17) "last-ok-ping-reply"
   18) "501"
   19) "last-ping-reply"
   20) "501"
   21) "down-after-milliseconds"
   22) "30000"
   23) "info-refresh"
   24) "502"
   25) "role-reported"
   26) "slave"
   27) "role-reported-time"
   28) "2029212"
   29) "master-link-down-time"
   30) "0"
   31) "master-link-status"
   32) "ok"
   33) "master-host"
   34) "127.0.0.1"
   35) "master-port"
   36) "6379"
   37) "slave-priority"
   38) "100"
   39) "slave-repl-offset"
   40) "5259427"

五、附录

哨兵故障转移日志详解

在上面的案例中，sentinel3完成了第一次故障转移：

让我们挨个分析每行日志：

故障检测阶段

+sdown master mymaster 127.0.0.1 6379：哨兵将主节点标记为主观下线(Subjectively Down)，表示当前哨兵认为主节点不可用
+odown master mymaster 127.0.0.1 6379 #quorum 3/2：哨兵集群达成共识，将主节点标记为客观下线(Objectively Down)，表示多个哨兵(3个中的2个)都认为主节点不可用

故障转移准备阶段

+new-epoch 1：开启新的配置纪元(epoch)，这是一个递增的计数器，用于标识集群配置的版本
+try-failover master mymaster 127.0.0.1 6379：开始尝试进行故障转移

领导者选举阶段

+vote-for-leader：哨兵节点开始投票选举领导者(leader)来执行故障转移操作
+elected-leader master mymaster 127.0.0.1 6379：成功选举出负责故障转移的哨兵领导者

从节点选择与提升阶段

+failover-state-select-slave：开始寻找合适的从节点进行提升
+selected-slave slave 127.0.0.1:6381：选择了6381端口的从节点作为新的主节点
+failover-state-send-slaveof-noone：向选中的从节点发送SLAVEOF NO ONE命令，使其成为主节点
+failover-state-wait-promotion：等待从节点被提升为主节点
+promoted-slave slave 127.0.0.1:6381：从节点6381成功被提升为新的主节点

重新配置从节点阶段

+failover-state-reconf-slaves：开始重新配置其他从节点
+slave-reconf-sent：向其他从节点(6380)发送命令，使其复制新的主节点
+slave-reconf-inprog：从节点正在重新配置
+slave-reconf-done：从节点完成重新配置

故障转移完成阶段

-odown master mymaster 127.0.0.1 6379：清除主节点的客观下线状态
+failover-end master mymaster 127.0.0.1 6379：故障转移顺利完成
+switch-master mymaster 127.0.0.1 6379 127.0.0.1 6381：更新主节点信息，从6379切换到6381

后续处理

+slave slave 127.0.0.1:6380：将6380节点添加为新主节点的从节点
+slave slave 127.0.0.1:6379：原主节点6379恢复后，被添加为新主节点的从节点
+sdown slave 127.0.0.1:6379：原主节点6379因为尚未完全恢复被标记为主观下线

Redis（七）：多机部署之主从复制模式

Mon, 14 Jul 2025 10:29:18 +0800

Redis多机部署有三种模式：主从复制模式、Sentinel（哨兵）模式、Cluster模式，本篇文章将基于Redis6.2.1讲解主从复制模式的部署、使用、常见问题等。

一、主从复制模式的部署

一般来说主从复制模式要用多台机器部署，由于资源有限，下面在一台机器上部署一主两从的主从复制架构。其架构图如下所示：

1、独立启动三个服务

创建3个文件夹：6379、6380、6381，参考单台Redis的安装教程：CentOS安装Redis （只看前三步到运行即可），将redis.conf配置文件以及redis-server、redis-cli配置文件复制到每个文件夹

├── 6379
│   ├── redis-cli
│   ├── redis.conf
│   ├── redis-server
├── 6380
│   ├── redis-cli
│   ├── redis.conf
│   ├── redis-server
└── 6381
    ├── redis-cli
    ├── redis.conf
    └── redis-server

然后逐个使用命令./reids-server ./redis.conf启动服务，每个服务的启动日志类似如下所示：

2520:C 11 Jul 2025 11:11:08.314 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
2520:C 11 Jul 2025 11:11:08.314 # Redis version=6.2.1, bits=64, commit=00000000, modified=0, pid=2520, just started
2520:C 11 Jul 2025 11:11:08.314 # Configuration loaded
2520:M 11 Jul 2025 11:11:08.316 * Increased maximum number of open files to 10032 (it was originally set to 1024).
2520:M 11 Jul 2025 11:11:08.316 * monotonic clock: POSIX clock_gettime
2520:M 11 Jul 2025 11:11:08.317 * Running mode=standalone, port=6379.
2520:M 11 Jul 2025 11:11:08.317 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
2520:M 11 Jul 2025 11:11:08.317 # Server initialized
2520:M 11 Jul 2025 11:11:08.317 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
2520:M 11 Jul 2025 11:11:08.318 * Ready to accept connections

这时候启动的三个服务全都是主服务器，即master节点。 它们都是独立的server，相互之间并没有任何关系。

2、主从模式架构部署

上一步已经启动了三个独立的Redis Server，现在将6379端口号的服务作为master节点，将6380、6381端口号的服务作为从节点做主从复制模式配置，其结构图如下所示：

方法一：replicaof命令

第一种方式就是使用redis-cli连接6380、6381服务，运行 replicaof 命令：

REPLICAOF localhost 6379

以6380服务运行该命令为例，运行该命令的时候，6379服务的server.log日志会打印如下输出：

2520:M 11 Jul 2025 11:22:13.107 * Replica [::1]:6380 asks for synchronization
2520:M 11 Jul 2025 11:22:13.107 * Partial resynchronization not accepted: Replication ID mismatch (Replica asked for 'a1659b41814b4c2efffd56d4e1d4eb175a66f458', my replication IDs are '2cd002f50c115cfad4235840a1d16b047d05c097' and '0000000000000000000000000000000000000000')
2520:M 11 Jul 2025 11:22:13.107 * Replication backlog created, my new replication IDs are '63830caba228eb487be0aaaf561cee0258e21c3e' and '0000000000000000000000000000000000000000'
2520:M 11 Jul 2025 11:22:13.107 * Starting BGSAVE for SYNC with target: disk
2520:M 11 Jul 2025 11:22:13.141 * Background saving started by pid 2580
2580:C 11 Jul 2025 11:22:13.169 * DB saved on disk
2580:C 11 Jul 2025 11:22:13.169 * RDB: 4 MB of memory used by copy-on-write
2520:M 11 Jul 2025 11:22:13.198 * Background saving terminated with success
2520:M 11 Jul 2025 11:22:13.198 * Synchronization with replica [::1]:6380 succeeded

从日志中可以看到，6380运行preplicaof命令后，6379服务首先运行BGSAVE命令将自己的完整数据以RDB的格式备份到了硬盘上，然后将该文件传输给了6380服务。

看看6380服务的日志：

2529:S 11 Jul 2025 11:22:13.105 * Before turning into a replica, using my own master parameters to synthesize a cached master: I may be able to synchronize with the new master with just a partial transfer.
2529:S 11 Jul 2025 11:22:13.105 * Connecting to MASTER localhost:6379
2529:S 11 Jul 2025 11:22:13.106 * MASTER <-> REPLICA sync started
2529:S 11 Jul 2025 11:22:13.106 * REPLICAOF localhost:6379 enabled (user request from 'id=3 addr=127.0.0.1:32840 laddr=127.0.0.1:6380 fd=8 name= age=63 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=44 qbuf-free=40910 argv-mem=22 obl=0 oll=0 omem=0 tot-mem=61486 events=r cmd=replicaof user=default redir=-1')
2529:S 11 Jul 2025 11:22:13.106 * Non blocking connect for SYNC fired the event.
2529:S 11 Jul 2025 11:22:13.106 * Master replied to PING, replication can continue...
2529:S 11 Jul 2025 11:22:13.107 * Trying a partial resynchronization (request a1659b41814b4c2efffd56d4e1d4eb175a66f458:1).
2529:S 11 Jul 2025 11:22:13.167 * Full resync from master: 63830caba228eb487be0aaaf561cee0258e21c3e:0
2529:S 11 Jul 2025 11:22:13.167 * Discarding previously cached master state.
2529:S 11 Jul 2025 11:22:13.198 * MASTER <-> REPLICA sync: receiving 175 bytes from master to disk
2529:S 11 Jul 2025 11:22:13.198 * MASTER <-> REPLICA sync: Flushing old data
2529:S 11 Jul 2025 11:22:13.198 * MASTER <-> REPLICA sync: Loading DB in memory
2529:S 11 Jul 2025 11:22:13.200 * Loading RDB produced by version 6.2.1
2529:S 11 Jul 2025 11:22:13.200 * RDB age 0 seconds
2529:S 11 Jul 2025 11:22:13.200 * RDB memory usage when created 1.83 Mb
2529:S 11 Jul 2025 11:22:13.200 * MASTER <-> REPLICA sync: Finished with success

6380进行了一次全量数据同步：6380接收到主服务器6379发送过来的数据保存到了硬盘上，之后清空自己所有的旧数据，然后从硬盘加载了RDB数据文件。

方法二：配置文件

使用上述方法一可以暂时实现主从模式架构的部署，但是服务器一重启就失效了，为了能永久有效，需要将该命令写入配置文件：修改6380和6381服务的redis.conf配置文件

replicaof localhost 6379
masterauth <master-password>  #如果主服务器开启password需要新增这项配置
masteruser <username>		#如果主服务器开启了ACL则需要新增这项配置

该配置项和命令是一样的。

这样修改完成后，再重新启动redis就不会丢失主从模式架构的配置了。

3、主从模式架构验证

上面已经将一主两从的主从复制模式架构搭建好了，现在验证下是否已经成功，如果我们在主服务器上设置了一个key，在从服务器上能查询到该key，则表示主从模式架构已经生效了。

可以看到主服务器新增的key，已经顺利同步到了两个从服务器上，表示我们主从复制模式的架构已经搭建好了。

role：查看服务器角色

用户可以通过执行role命令查看服务的当前角色。

主服务器执行role命令：

127.0.0.1:6379> role
1) "master"         
2) (integer) 12577
3) 1) 1) "::1"
      2) "6380"
      3) "12563"
   2) 1) "::1"
      2) "6381"
      3) "12577"
127.0.0.1:6379>

第一个元素master表示是主服务器角色
第二个元素12577是复制偏移量（replication offset），它是一个整数，记录了主服务器目前向复制数据流发送的数据数量
第三个元素是一个数组，表示主服务器属下的从服务器。每个元素都由三个子元素组成：
- 第1个子元素为从服务器的IP地址
- 第2个子元素为从服务器的端口号
- 第3个子元素则为从服务器的复制偏移量。从服务器的复制偏移量记录了从服务器通过复制数据流接收到的复制数据数量，当从服务器的复制偏移量与主服务器的复制偏移量保持一致时，它们的数据就是一致的。在这个例子中并不一致，这是正常的，因为从服务器发送数据给从服务器，从服务器需要时间同步，再者也存在网络延迟。

从服务器执行role命令：

localhost:6381> role
1) "slave"
2) "localhost"
3) (integer) 6379
4) "connected"
5) (integer) 13095

数组的第1个元素是字符串"slave"，它表示这个服务器的角色是从服务器。
数组的第2个元素和第3个元素记录了这个从服务器正在复制的主服务器的IP地址和端口号。
数组的第4个元素是主服务器与从服务器当前的连接状态，这个状态的值及其表示的意义如下：
- "none"：主从服务器尚未建立连接。
- "connect"：主从服务器正在握手。
- "connecting"：主从服务器成功建立了连接。
- "sync"：主从服务器正在进行数据同步。
- "connected"：主从服务器已经进入在线更新状态。
- "unknown"：主从服务器连接状态未知。
数组的第5个元素是从服务器当前的复制偏移量。

info replication

在之前的文章Redis（一）：Redis数据类型和常用命令介绍过info命令，其中info命令有个子命令info replication可以查看主从复制信息，包括角色（master/slave）、从节点列表、复制偏移量、延迟等。

在主服务器上执行info replication命令：

127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=::1,port=6380,state=online,offset=14201,lag=1
slave1:ip=::1,port=6381,state=online,offset=14201,lag=1
master_failover_state:no-failover
master_replid:63830caba228eb487be0aaaf561cee0258e21c3e
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14201
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14201

从该输出上可以看出该节点的角色信息、从节点数量以及从节点的ip和端口号、状态、延迟等信息。

在从服务器上执行info replication命令：

localhost:6381> info replication
# Replication
role:slave
master_host:localhost
master_port:6379
master_link_status:up
master_last_io_seconds_ago:8
master_sync_in_progress:0
slave_repl_offset:14901
slave_priority:100
slave_read_only:1
connected_slaves:0
master_failover_state:no-failover
master_replid:63830caba228eb487be0aaaf561cee0258e21c3e
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14901
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:10235
repl_backlog_histlen:4667

replicaof no one

replicaof no one 在从服务器上执行之后，会将从服务器停止复制，并变回主服务器。

二、数据同步机制

当用户将一个服务器设置为从服务器，让它去复制另一个服务器的时候，主从服务器需要通过数据同步机制来让两个服务器的数据库状态保持一致。

1、完整同步

当一个Redis服务器接收到REPLICAOF命令，开始对另一个服务器进行复制的时候，主从服务器会执行以下操作：

主服务器执行BGSAVE命令，生成一个RDB文件，并使用缓冲区存储起在BGSAVE命令之后执行的所有写命令。
当RDB文件创建完毕，主服务器会通过套接字将RDB文件传送给从服务器。
从服务器在接收完主服务器传送过来的RDB文件之后，就会载入这个RDB文件，从而获得主服务器在执行BGSAVE命令时的所有数据。
当从服务器完成RDB文件载入操作，并开始上线接受命令请求时，主服务器就会把之前存储在缓存区中的所有写命令发送给从服务器执行。

因为主服务器存储的写命令都是在执行BGSAVE命令之后执行的，所以当从服务器载入完RDB文件，并执行完主服务器存储在缓冲区中的所有写命令之后，主从服务器包含的数据库数据将完全相同。

这个通过创建、传送并载入RDB文件来达成数据一致的步骤，我们称之为完整同步操作。每个从服务器在刚开始进行复制的时候，都需要与主服务器进行一次完整同步。

完整流程图如下所示：

2、部分同步

主从服务器在执行完完整同步操作之后，它们的数据就达到了一致状态，但这种一致并不是永久的：每当主服务器执行了新的写命令之后，它的数据库就会被改变，这时主从服务器的数据一致性就会被破坏。

为了让主从服务器的数据一致性可以保持下去，让它们一直拥有相同的数据，Redis会对从服务器进行在线更新：每当主服务器执行完一个写命令之后，它就会将相同的写命令或者具有相同效果的写命令发送给从服务器执行。

只要从服务器一直与主服务器保持连接，在线更新操作就会不断进行，使得从服务器的数据库可以一直被更新，并与主服务器的数据库保持一致。

数据一致性问题

每当主服务器执行完一个写命令之后，它就会将相同的写命令或者具有相同效果的写命令发送给从服务器执行以保持主从数据的一致性。但是由于网络延迟以及数据处理需要时间，在主服务器执行完写命令之后，直到从服务器也执行完相同写命令的这段时间里，主从服务器的数据库将出现短暂的不一致。

此外，主服务器也可能因故障下线，这时候可能还没来得及将同步命令发送出去，这同样可能会导致出现主从数据不一致的情况。

可以看到，数据一致性问题在主从复制模式中是没有办法杜绝的，对于数据一致性要求比较高的场景，最好直接读主服务器。

redis提供了两个参数设置，可以尽可能的降低出现数据不一致情况发生的概率：min-replicas-to-write、min-replicas-max-lag。

min-replicas-to-write 和 min-replicas-max-lag 搭配使用可以实现主节点写入熔断，确保数据同步的可靠性。

min-replicas-to-write

作用：定义主节点（master）在执行写操作时，要求至少连接的从节点（replica）数量。如果当前连接的从节点数少于该值，主节点会拒绝写请求。
应用场景：例如，设置为3时，主节点会检查是否有至少3个从节点处于正常连接状态。若不满足条件，写操作将被拒绝，从而避免数据写入后无法同步到足够多的从节点，降低数据丢失风险
默认值：未显式配置时，主节点不会检查从节点数量，可能导致数据不一致。

min-replicas-max-lag

作用：设置从节点与主节点之间的最大复制延迟（秒数）。若从节点的延迟超过该阈值，主节点会将其视为“不可用”。
应用场景：例如，设置为10时，主节点会检查所有从节点的复制延迟是否在10秒内。若延迟超过10秒的从节点数量不满足min-replicas-to-write的要求，主节点同样会拒绝写请求
默认值：未配置时，主节点不会检查延迟

这两个参数通常配合使用，主要解决以下问题：

异步复制的数据丢失：Redis默认异步复制，主节点不会等待从节点确认写操作。通过这两个参数，可以确保写入时至少有N个从节点处于低延迟状态，提高数据可靠性
脑裂问题：当网络分区导致主节点与部分从节点断开时，旧主节点可能继续接收写请求，但新主节点已被选举。通过限制写条件，旧主节点会因不满足从节点数量或延迟要求而拒绝写入，减少数据不一致

比如以下配置：

min-replicas-to-write 2
min-replicas-max-lag 10

表示：至少需要2个从节点连接且延迟不超过10秒，主节点才允许写入。

从节点重连

在主从复制模式中，如果从节点突然挂掉了，在挂掉的期间主节点还做了很多写操作，从节点重新上线后会发生什么？

当一个Redis服务器成为另一个服务器的主服务器时，它会把每个被执行的写命令都记录到一个特定长度的先进先出队列（复制积压缓冲区）中。当断线的从服务器尝试重新连接主服务器的时候，主服务器将检查从服务器断线期间，被执行的那些写命令是否仍然保存在队列里面。如果是，那么主服务器就会直接把从服务器缺失的那些写命令发送给从服务器执行，从服务器通过执行这些写命令就可以重新与主服务器保持一致，这样就避免了重新进行完整同步的麻烦。

现在模拟下这个过程，已知现在的架构如下所示：

我现在模拟这个过程，将6380从节点使用shutdown命令退出redis进程，之后6379服务执行一个写命令，看看6380服务重新上线之后会发生什么。

主服务的日志：

1842:M 11 Jul 2025 16:43:38.816 # Connection with replica [::1]:6380 lost.
1842:M 11 Jul 2025 16:43:57.618 * Replica [::1]:6380 asks for synchronization
1842:M 11 Jul 2025 16:43:57.618 * Partial resynchronization request from [::1]:6380 accepted. Sending 47 bytes of backlog starting from offset 1810.

从服务的日志：

1951:S 11 Jul 2025 16:43:57.616 * Loading RDB produced by version 6.2.1
1951:S 11 Jul 2025 16:43:57.616 * RDB age 19 seconds
1951:S 11 Jul 2025 16:43:57.617 * RDB memory usage when created 1.85 Mb
1951:S 11 Jul 2025 16:43:57.617 * DB loaded from disk: 0.001 seconds
1951:S 11 Jul 2025 16:43:57.617 * Before turning into a replica, using my own master parameters to synthesize a cached master: I may be able to synchronize with the new master with just a partial transfer.
1951:S 11 Jul 2025 16:43:57.617 * Ready to accept connections
1951:S 11 Jul 2025 16:43:57.617 * Connecting to MASTER localhost:6379
1951:S 11 Jul 2025 16:43:57.618 * MASTER <-> REPLICA sync started
1951:S 11 Jul 2025 16:43:57.618 * Non blocking connect for SYNC fired the event.
1951:S 11 Jul 2025 16:43:57.618 * Master replied to PING, replication can continue...
1951:S 11 Jul 2025 16:43:57.618 * Trying a partial resynchronization (request 6cb93c7859fe76e9e1e334fe799eda6fdb55fffc:1810).
1951:S 11 Jul 2025 16:43:57.619 * Successful partial resynchronization with master.
1951:S 11 Jul 2025 16:43:57.619 * MASTER <-> REPLICA sync: Master accepted a Partial Resynchronization.

从节点服务重启的时候先从本地加载RDB文件恢复之前的数据，连接主服务器成功以后尝试发起部分同步请求，主服务器接受了部分同步请求发送从服务器断线以后丢失的命令数据，从服务器最终同步成功。

3、复制积压缓冲区

上面的部分同步功能很依赖于主服务器的复制积压缓冲区，复制积压缓冲区越大，意味着从节点可以离线的时间越长。复制积压缓冲区的设置可以在主服务器的redis.conf配置文件中设置：

repl-backlog-size 1mb  
repl-backlog-ttl 3600

repl-backlog-size

设置复制积压缓冲区的大小。积压缓冲区是一个缓存区，用于在从节点（replica）因某些原因断开连接时累积主节点的数据。这样，当从节点重新连接时，通常不需要执行完整的全量同步（full resync），而只需通过部分同步（partial resync）传递从节点在断开期间缺失的数据部分。

复制积压缓冲区越大，从节点能容忍的断开时间越长，后续也更可能通过部分同步恢复数据。

该缓冲区仅在至少有一个从节点连接时才会分配内存空间，默认值是1Mb。

repl-backlog-ttl

当主节点（master）在一段时间内没有任何连接的从节点（replica）时，积压缓冲区（backlog）将被释放。该配置项用于设定从最后一个从节点断开连接开始，经过多少秒后积压缓冲区会被自动释放。

注意：从节点（replica）永远不会因超时而释放积压缓冲区，因为它们后续可能被提升为主节点，必须确保能够与其他从节点正确进行“部分重新同步”（partial resynchronization）。因此，从节点会始终保留积压缓冲区。

值为0表示永不释放积压缓冲区。

默认值：3600（即缓冲区在最后一个从节点断开后1小时释放）

4、无需硬盘的复制

主服务器在进行完整同步的时候，需要在本地创建RDB文件，然后通过套接字将这个RDB文件传送给从服务器。但是，如果主服务器所在宿主机器的硬盘负载非常大或者性能不佳，那么创建RDB文件引起的大量硬盘写入将对主服务器的性能造成影响，并导致复制进程变慢。

为了解决这个问题，Redis从2.8.18版本开始引入无须硬盘的复制特性（diskless replication）：启用了这个特性的主服务器在接收到REPLICAOF命令时将不会再在本地创建RDB文件，而是会派生出一个子进程，然后由子进程通过套接字直接将RDB文件写入从服务器。这样主服务器就可以在不创建RDB文件的情况下，完成与从服务器的数据同步。

要使用无须硬盘的复制特性，可以使用如下配置

repl-diskless-sync no #核心配置
repl-diskless-sync-delay 5
repl-diskless-load disabled

repl-diskless-sync

该配置项的值为no时使用rdb传输，为yes时使用无盘传输。

该配置项为节点，如果无法通过增量同步继续复制过程，则需要执行全量同步（full synchronization）。此时，主节点会生成RDB文件并传输给从节点。

RDB文件的传输可通过两种方式实现：

磁盘备份模式（Disk-backed）
- 主节点创建一个子进程，将RDB文件写入磁盘。
- 父进程随后将磁盘中的RDB文件增量传输给从节点。
无盘模式（Diskless）：
- 主节点创建一个子进程，直接通过套接字（socket）将RDB文件流式传输给从节点，完全不经过磁盘。

两种模式的差异：

磁盘备份模式：生成RDB文件期间，新连接的从节点会排队等待，当前子进程完成后即可共享同一RDB文件。
无盘模式：传输一旦开始，新到达的从节点需等待当前传输完成后才能启动新一轮传输。

无盘模式的延迟配置：启用无盘复制时，主节点会等待一段可配置的时间（秒），以期望更多从节点加入，从而实现并行传输（默认值：repl-diskless-sync-delay 5）。

适用场景：在磁盘性能较差但网络带宽较高的环境下，无盘复制的性能更优。

repl-diskless-sync-delay

该配置项的值为整数，单位秒，表示当启用无盘复制（diskless replication）时，主节点在启动RDB传输子进程前等待的延迟时间（单位为秒）。这一延迟的目的是让更多从节点能够加入当前的同步批次，从而避免重复生成RDB文件。

重要性：一旦RDB传输开始，新连接的从节点将无法立即加入同步，只能排队等待下一次RDB传输。因此，主节点通过延迟等待，尽可能让更多从节点在同一批次完成同步。

默认值：5秒。若设置为0秒，则主节点会立即开始传输RDB，不等待任何从节点加入。

repl-diskless-load

该配置项用于从服务器节点RDB误判加载功能的开启。它有三种值：

disabled：禁用无盘加载，优先将RDB写入磁盘再加载（默认安全选项）。
on-empty-db：仅在数据库为空时启用无盘加载（完全安全时使用）。
swapdb：解析套接字数据时，在内存中保留当前数据库的副本。需确保内存充足，否则可能触发OOM。

我们知道使用repl-diskless-sync配置项可以让主服务器实现无盘复制，但是从服务器默认还是需要先下载rdb文件再从rdb文件恢复数据的。repl-diskless-load配置项则可以让从服务器节点实现无盘加载，即从从服务器获取到rdb文件后不下载到本地，直接从内存恢复数据。

注意：RDB无盘加载是实验性功能。在此配置下，从节点（replica）不会立即将RDB文件存储到磁盘，可能导致故障转移期间的数据丢失。此外，若Redis模块未处理I/O读取，在与主节点初始同步阶段出现I/O错误时，Redis可能会中止。如果能接受该风险，就可以使用该项功能。

优劣分析：

无盘加载的优势：磁盘速度通常低于网络，存储和加载RDB文件可能增加复制时间（甚至增加主节点的写时复制内存和从节点缓冲区压力）。
无盘加载的风险：直接从套接字解析RDB文件时，可能需要在完整接收RDB前清空当前数据库内容，导致数据不一致或内存不足（OOM）。

三、可写的从服务器

从Redis 2.6版本开始，Redis的从服务器在默认状态下只允许执行读命令。如果用户尝试对一个只读从服务器执行写命令，那么服务器将拒绝写入。

Redis之所以将从服务器默认设置为只读服务器，是为了确保从服务器只能通过与主服务器进行数据同步来得到更新，从而保证主从服务器之间的数据一致性。

但在某些情况下，我们可能想要将一些不太重要或者临时性的数据存储在从服务器中，或者不得不在从服务器中执行一些带有写性质的命令（比如ZINTERSTORE命令，它只能将计算结果存储在数据库中，不能直接返回计算结果）。这时我们可以通过将replica-read-only配置选项的值设置为no来打开从服务器的写功能：

replica-read-only <yes|no>

注意该配置是作用在从服务器上的。

使用从服务器写功能可能会导致和主服务器写的key冲突，这点需要注意，在从服务器上写入key时尽量设置ttl从而保证和主服务器的数据一致性。

Redis（六）：Redis整合Lua

Tue, 08 Jul 2025 14:08:33 +0800

lua是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

一、使用Lua脚本的好处

Redis与Lua脚本的整合为开发者提供了一种在Redis服务器端执行复杂逻辑的强大能力，这种组合不仅保证了操作的原子性，还能显著减少网络开销，提升系统性能。关于Lua，可以参考 Lua教程。

1.原子性保障

Redis执行Lua脚本时具有天然的原子性，脚本中的所有命令会作为一个整体执行，要么全部成功，要么全部失败。这对于需要多步操作的业务场景至关重要。相比传统的WATCH/MULTI/EXEC事务机制，Lua脚本能更好地规避网络波动导致的部分命令执行失败问题。

2.性能优化

减少网络开销：通过将多个命令打包成一个脚本执行，有效减少网络通信次数。测试表明，对于需要连续执行5个命令的操作，使用脚本可将网络延迟降低80%
脚本缓存：Lua脚本在Redis中会被缓存，后续调用直接使用SHA1摘要执行即可。

Lua脚本支持条件判断、循环等复杂控制结构，能够实现超出单一Redis命令能力的业务逻辑，如分布式锁、限流算法、复杂事务等。

二、Redis中的脚本命令

redis中关于脚本相关的命令一共分为两类：EVAL开头的脚本执行相关的命令以及SCRIPT相关的子命令系列。

1、redis调用lua脚本

eval命令用于redis执行lua脚本，一共有两个命令：eval命令以及evalsha命令。

eval

eval命令用于直接执行lua脚本，其语法格式如下：

EVAL script numkeys key [key ...] arg [arg ...]

evalsha

EVALSHA 是 Redis 中用于执行预加载 Lua 脚本的命令，通过脚本的 SHA1 摘要值调用已缓存的脚本，避免重复传输脚本内容，提升执行效率。其语法格式如下所示：

EVALSHA sha1 numkeys key [key ...] arg [arg ...]

2、lua脚本调用redis

上面介绍了在redis中如何调用lua脚本，那么在lua脚本中如何调用redis命令实现与redis server交互呢？

在lua脚本中使用redis.call和redis.pcall执行redis命令。

redis.call

redis.call() 是 Redis Lua 脚本中用于执行 Redis 命令的核心函数，其语法格式如下：

redis.call("命令名称", 参数1, 参数2, ...)

参数说明：

‌命令名称‌（字符串）： Redis 命令的名称（如 "SET"、"GET"、"HMSET" 等），需严格遵循 Redis 命令规范。
‌参数

命令所需的参数，数量和类型取决于具体命令。例如：
- redis.call("SET", "key", "value")
- redis.call("HGETALL", "user:1001")

返回值：‌

返回 Redis 命令的执行结果（类型取决于命令）：字符串（如 GET）、整数（如 INCR）、数组（如 HGETALL）、nil（键不存在时）等。
‌若命令执行失败‌（如语法错误、键不存在等），会抛出 Lua 错误并中断脚本。

举例：

127.0.0.1:6379> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 name zhangsan
OK
127.0.0.1:6379> get name
zhangsan

redis.pcall

redis.pcall中的p指的是"protected"，即受保护的调用，它的语法格式和redis.call一模一样，但是和redis.call不同的是，redis.pcall命令遇到错误会继续执行脚本，类似于java中的"try catch"：

#redis.call正常调用的返回
127.0.0.1:6379> eval "return redis.call('hset','zhagnsan','name','zhangsan')" 0
1
127.0.0.1:6379> 
#redis.call报错的返回
127.0.0.1:6379> eval "return redis.call('hset','zhagnsan')" 0
ERR Error running script (call to f_9f8009f869f9b829b0aa06a921626f6e8312fb97): @user_script:1: @user_script: 1: Wrong number of args calling Redis command From Lua script
#redis.pcall的返回
127.0.0.1:6379> eval "return redis.pcall('hset','zhagnsan')" 0
@user_script: 1: Wrong number of args calling Redis command From Lua script

3、SCRIPT命令

redis中script命令用于管理lua脚本，其有如下子命令：script load、script exists、script flush、script kill、script debug、script help。

script load

script load命令用于将lua脚本预加载到redis服务器并返回脚本的sha1校验和，其命令格式如下所示：

script LOAD

示例：

127.0.0.1:6379> script load 'return {1,2,3,4}'
b70175b4152c3db555480fca35498644b6b16f01
127.0.0.1:6379> evalsha b70175b4152c3db555480fca35498644b6b16f01 0
1
2
3
4

script exists

script exists命令用于检查某个脚本是否存在，其命令格式如下所示：

script EXISTS <sha1> [<sha1> ...]

示例：

127.0.0.1:6379> script exists b70175b4152c3db555480fca35498644b6b16f01
1
127.0.0.1:6379> script exists b70175b4152c3db555480fca35498644b6b16f00
0

script flush

script flush命令用于清空redis预加载的脚本，其命令如下所示：

script FLUSH [ASYNC|SYNC]

示例：

127.0.0.1:6379> script exists b70175b4152c3db555480fca35498644b6b16f01
1
127.0.0.1:6379> script flush
OK
127.0.0.1:6379> script exists b70175b4152c3db555480fca35498644b6b16f01
0

script kill

script kill命令用于终止正在执行的脚本（仅当脚本未执行写操作时有效），其命令格式如下所示：

script kill

举例：

127.0.0.1:6379> script kill
NOTBUSY No scripts in execution right now.

127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379>

script debug

Redis的SCRIPT DEBUG命令用于调试Lua脚本，是开发者排查脚本问题的重要工具。

其命令格式如下所示：

SCRIPT DEBUG (YES|SYNC|NO)

YES：开启非阻塞异步调试模式（输出到客户端）
SYNC：开启阻塞同步调试模式（会暂停脚本执行）
NO：关闭调试模式

调试输出会包含：

执行的Lua代码行号
局部/全局变量值变化
Redis命令调用详情
返回值信息

由于debug命令对服务端影响较大，在生产环境务必保证debug NO

三、分布式锁实现原理

这里简单说下分布式锁的设计，先不说具体的实现了。

1、加锁

在分布式锁的使用场景中，我们要求每个客户端在执行临界区代码之前要先获取锁，获取锁成功了才能进入临界区。使用setnx命令似乎能完美解决这个问题：先判断key存不存在，不存在则设置key和value；如果存在则不作任何操作。但是我们加锁是需要超时时间的，setnx命令并不支持添加超时时间。

可以使用set命令代替setNx命令，一般我们使用set命令都是简单使用set key value设置一个值，实际上该命令的完整语法如下所示：

set key value [EX seconds|PX milliseconds|EXAT timestamp|PXAT milliseconds-timestamp|KEEPTTL] [NX|XX] [GET]

可以看到set命令本身支持NX操作，实际上setNX是set命令中的一个特殊快捷方式。

setNX key value = set key value NX

而且set命令支持有效期参数，所以最好使用set命令实现加锁操作，比如，我们要加锁10秒钟，可以使用命令：

set lock:business:1 zhangsan EX 10 NX

key是lock:business:1，value值是zhangsan表示是zhangsan进行的加锁（这里是zhangsan，代表的是锁的持有者，也可以是任意uuid，只要以后能解锁就行），加锁时间10秒钟，10秒钟之内如果无人解锁将自动解锁。

set命令一个命令就完成了以下几件事：

key存不存在
为key赋值
添加有效期

而且set命令是原子操作不存在线程安全性问题，所以不需要使用lua脚本实现加锁。

2、解锁

解锁步骤分为两步：

第一步： 判断前来请求解锁的人是否是当前锁的持有者，如果不是锁的持有者来解锁应当不执行解锁操作

第二步： 解锁，即删除key

将redis解锁的过程翻译成需要执行的命令，可以等价于如下步骤：

输入需要解锁的key以及key的值value（锁的持有者），redis根据输入的key使用get命令获取到value值和输入的value比对，如果不相同，则不做任何操作；如果相同，则调用del命令删除key实现解锁。

可以看到，解锁涉及到多个步骤，客户端执行这些步骤无法保证其原子性，这时候就可以使用lua脚本了：

--如果key的值相等，则释放锁，这样保证：谁加的锁，谁释放。
if redis.call('GET',KEYS[1]) == ARGV[1]
then
	return redis.call('DEL',KEYS[1])
else
	return 0
end

使用eval命令

eval script 1 key value

就可以实现解锁了。

END.

Redis（五）：Redis Stream

Thu, 03 Jul 2025 14:00:08 +0800

在之前的文章《Redis（二）：Redis消息队列》中已经介绍过Redis中使用List以及发布订阅两种模式实现的消息队列，其中发布订阅模式比List模式功能更强大，但是有很大的缺陷：

消息没有持久化，如果消费者断线重连，消息会丢失
没有ack机制，无法保证消息被成功消费。
Redis服务重启后消息会丢失。

Redis Stream是在5.0版本引入的新消息队列，它能持久化消息并且带ACK机制，甚至还有类似Kafka一样的ConsumerGroup（消费者组）协同消费消息，可以说完全弥补了发布订阅模式的所有缺点。

这篇文章单独把Redis Stream拿出来说，是因为我认为到目前为止，Redis Stream是Redis最复杂的类型了。Stream类型不像BitMap或者GEO操作底层存储还是五种基本数据类型之一，Stream类型的key使用type命令得到的类型就是"stream"，它是一个独立的类型。

以下内容均基于Redis 6.2.1。

一、Stream基本命令

1、xadd

xadd命令用于向Stream中添加新消息，其完整命令如下所示：

XADD key [NOMKSTREAM] [MAXLEN|MINID [=|~] threshold [LIMIT count]] *|ID field value [field value ...]

该命令比较复杂，下面一部分一部分来看：

key： 指定要添加消息的 Stream 名称

NOMKSTREAM： 可选参数，如果指定，当 key 不存在时不会自动创建新的 Stream

长度限制参数：

MAXLEN [=|~] threshold：限制 Stream 的最大长度，超过时会删除旧消息
- = 表示精确限制（性能较低）
- ~ 表示近似限制（性能更高，默认）
MINID [=|~] threshold：只保留 ID 大于等于指定值的消息（Redis 6.2+）

LIMIT count：与 MAXLEN/MINID 配合使用，限制每次修剪的消息数量

消息ID：

*：让 Redis 自动生成 ID（格式为<毫秒时间戳>-<序列号>，如1717020000000-5）
手动指定 ID：必须大于 Stream 中已有最大 ID，否则会报错

field value [field value ...]：键值对形式的消息内容，可以包含多个字段

举例：向Stream新增一条数据：

127.0.0.1:6379> xadd stream * name zhangsan age 15 sex man
1751425687108-0  #返回消息id
127.0.0.1:6379> type stream
stream
127.0.0.1:6379>

注意，这里添加了多个field value，但是在Stream中还是一个元素。

2、xrange

xrange用于按照消息 ID 的范围查询 Stream 中的消息。其具体命令格式如下：

xrange key start end [COUNT count]

key：要查询的 Stream 名称（必填）

start：起始消息 ID（必填）

特殊值 - 表示最小 ID（即 Stream 中的第一条消息）
可以指定具体的消息 ID（如 1526919030474-55）

end：结束消息 ID（必填）

特殊值 + 表示最大 ID（即 Stream 中的最新消息）
可以指定具体的消息 ID

[COUNT count]：可选参数，限制返回的消息数量

如果不指定，默认返回范围内的所有消息
指定后只返回最多 count 条消息

举例：查询stream中的所有消息

127.0.0.1:6379> xrange stream - +
1751425687108-0   #消息id，之后是消息体
name
zhangsan
age
15
sex
man
127.0.0.1:6379>

3、xrevrange

xrevrange命令用于按照消息 ID 的反向顺序（从大到小）查询 Stream 中的消息。它与 xrange命令功能相似但遍历方向相反，特别适合获取最新的消息。其命令格式如下：

xrevrange key end start [COUNT count]

key：要查询的 Stream 名称（必填）

end：结束消息 ID（必填）

特殊值 + 表示最大 ID（即 Stream 中的最新消息）
可以指定具体的消息 ID（如 1526919030474-55）

start：起始消息 ID（必填）

特殊值 - 表示最小 ID（即 Stream 中的第一条消息）
可以指定具体的消息 ID

[COUNT count]：可选参数，限制返回的消息数量

如果不指定，默认返回范围内的所有消息
指定后只返回最多 count 条消息

举例：查询stream中的数据

127.0.0.1:6379> xrevrange stream + -
1751425687108-0
name
zhangsan
age
15
sex
man
127.0.0.1:6379>

4、xlen

xlen命令用于查询stream的长度，命令格式如下：

xlen key

xlen命令比较简单，举例：

127.0.0.1:6379> xlen stream
1
127.0.0.1:6379>

5、xread

xread是 Redis Stream 数据结构中用于读取消息的核心命令，支持阻塞和非阻塞模式，能够从一个或多个 Stream 中获取消息。其命令格式如下所示：

xread [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]

[COUNT count]：可选参数，限制从每个 Stream 中返回的消息数量

[BLOCK milliseconds]：可选参数，设置阻塞模式及超时时间（毫秒）

设置为0表示无限期阻塞
不设置此参数则为非阻塞模式

STREAMS key [key ...]：指定要读取的一个或多个 Stream 名称

ID [ID ...]：指定每个 Stream 的起始消息ID

$ 表示只读取最新消息（阻塞模式下常用）
0 或 0-0 表示从第一条消息开始读取
指定具体ID则读取该ID之后的消息

举例：非阻塞监听

127.0.0.1:6379> xread streams stream 0-0  #从第一条消息开始读取
stream
1751425687108-0 #第一条消息id
name
zhangsan
age
15
sex
man
1751436694812-0 #第二条消息id
zhangsan
age
127.0.0.1:6379>

举例：阻塞监听

阻塞监听有个问题，它和pub/sub模式不一样的是，pub/sub模式下的subscribe命令会持续监听，而xread命令监听到一条消息之后命令就结束了。

在实际使用中，为了能持续监听消费消息，而且不漏掉消息，需要记住消费的消息id，伪代码如下所示：

String lastId = "0-0"; // 初始从第一条消息开始
while(true) {
    // 从上次消费的位置继续读取
    Object msg = redis.execute("XREAD COUNT 10 BLOCK 5000 STREAMS users " + lastId);
    if (msg == null) continue;
    // 更新最后消费的ID
    lastId = getLastIdFrom(msg); 
    handleMessage(msg);
}

6、xtrim

xtrim是 Redis Stream 数据结构中用于修剪(trim)流长度的命令，它可以限制 Stream 中保存的消息数量或基于消息ID进行裁剪。Stream的使用过程中，其消息长度会越来越大，应当定期使用xtrim命令对其进行修剪。

xtrim命令的完整格式如下所示：

XTRIM key MAXLEN|MINID [=|~] threshold [LIMIT count]

key：Stream 的名称（必填）

策略选择：

MAXLEN：基于消息数量进行修剪
MINID：基于消息ID进行修剪（Redis 6.2+）

[=|~]：精确或近似修剪模式

=：精确修剪（默认）
~：近似修剪（提高性能）

threshold：阈值

对于 MAXLEN：保留的最大消息数量
对于 MINID：保留的最小消息ID（所有小于此ID的消息将被删除）

[LIMIT count]：每次迭代删除的消息数量限制（Redis 6.2+）

7、xdel

XDEL 是 Redis Stream 数据结构中用于删除指定消息的命令。其语法结构如下所示：

XDEL key ID [ID ...]

XDEL 命令会从指定的 Stream 中删除给定的消息ID，删除的消息会从内存中释放，如果被删除的消息存在于任何消费者组的 Pending Entries List (PEL) 中，它也会从这些PEL中移除，但不会影响消费者组的 last_delivered_id。

二、消费者组

前面介绍了xread命令已经能够从消息队列中读取消息了，但是xread命令有几个很大的缺陷：

无法记住已经消费的消息。它每次消费必须指定id；若是指定$，则实际上还是和发布订阅模式有一样的问题，若是客户端连接中断则有可能漏掉部分消息。
无ACK机制。

使用消费者组则能解决以上问题。消费者组消费消息的示意图如下所示：

每个消费者组都有若干个消费者，这些消费者协同消费消息。若是开启ACK，每个消费者接收到消息之后会将消息id放入自己维护的pending_ids列表中，表示还未ACK，待ACK后就将处理完的消息从pending_ids列表中移除。另外，每个消费者组还维护了last_deliverred_id表示最后一个投递给消费者的id，下次再消费则从此处开始。

如果某个消费者的pending_ids列表中有消息长时间没有ack，则可以将该消息重新转移给别的消费者让其重试解决。

1、xgroup

xgroup是 Redis Stream 中用于管理消费者组(Consumer Group)的核心命令，它提供了创建、配置和销毁消费者组的功能。其完整命令如下所示：

XGROUP 
[CREATE key groupname ID|$ [MKSTREAM]] 
[SETID key groupname ID|$] 
[DESTROY key groupname] 
[CREATECONSUMER key groupname consumername] 
[DELCONSUMER key groupname consumername]

注意，上述命令中的ID|$实际上是id-or-$。

create子命令

create子命令用于创建消费者组，完整命令如下：

XGROUP [CREATE key groupname ID|$ [MKSTREAM]]

key: Stream 名称（必填）

groupname: 消费者组名称（必填）

id-or-$: 起始消息ID（必填）

$ 表示只消费新消息（创建后添加的消息,当前Stream中的消息会全部忽略）
0 或 0-0 表示从第一条消息开始消费
指定具体ID则从该ID之后开始消费

[MKSTREAM]: 可选参数，如果Stream不存在则自动创建

127.0.0.1:6379> xgroup create stream consumer_group 0-0 #创建consumer_group消费者组从头开始消费stream的消息
OK
127.0.0.1:6379>

setid子命令

setid子命令用于重置消费者组读取位置，实际上是修改了消费者组的 last_delivered_id，完整命令如下：

XGROUP [SETID key groupname ID|$]

key: Stream 名称（必填）

groupname: 消费者组名称（必填）

id-or-$: 起始消息ID（必填）

$ 表示只消费新消息（创建后添加的消息）
0 或 0-0 表示从第一条消息开始消费
指定具体ID则从该ID之后开始消费

destroy子命令

destroy子命令用于删除消费者组，同时组内所有消费者也会被删除。完整命令如下所示：

XGROUP [DESTROY key groupname]

key: Stream 名称（必填）

groupname: 消费者组名称（必填）

createconsumer子命令

createconsumer子命令用于在现有消费者组中显式创建一个消费者，通常是不需要使用该命令显式创建消费者的，使用XREADGROUP命令会自动创建消费者。createconsumer子命令如下所示：

XGROUP [CREATECONSUMER key groupname consumername]

key: Stream 名称（必填）

groupname: 消费者组名称（必填）

consumername：消费者名称

delconsumer子命令

delconsumer子命令用于从消费者组中删除指定的消费者。delconsumer子命令如下所示：

XGROUP [DELCONSUMER key groupname consumername]

key: Stream 名称（必填）

groupname: 消费者组名称（必填）

consumername：消费者名称

2、xreadgroup

xreadgroup是 Redis Stream 中用于消费者组(Consumer Group)模式读取消息的核心命令，也是构建可靠消息系统的关键命令，通过消费者组模式实现了消息分发、负载均衡和消息确认机制，是Redis Stream最强大的特性之一。

该命令会自动过滤已经消费过的消息。

完整命令如下所示：

XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] ID [ID ...]

GROUP group consumer：指定消费者组名称和消费者名称

group：消费者组名称
consumer：消费者名称（自动创建不存在的消费者）

[COUNT count]：限制从每个 Stream 中返回的消息数量

[BLOCK milliseconds]：设置阻塞模式及超时时间（毫秒）

设置为0表示无限期阻塞
不设置此参数则为非阻塞模式

[NOACK]：不将消息添加到 PEL (Pending Entries List)

使用此参数后消息会被视为已确认，无需后续 XACK
适用于不需要消息确认的场景

STREAMS key [key ...]：指定要读取的一个或多个 Stream 名称

ID [ID ...]：指定每个 Stream 的起始消息ID

>：特殊ID，表示只读取从未分发给该消费者的新消息
0 或 0-0：从消费者组的 PEL (Pending Entries List) 中重新读取未确认的消息
具体ID：从指定ID之后的消息开始读取

127.0.0.1:6379> xreadgroup group consumer_group kdyzm_consumer_1 block 0 streams stream >
stream
1751425687108-0
name
zhangsan
age
15
sex
man
1751436694812-0
zhangsan
age
1751438226276-0
name
zhangsan
1751438232352-0
name
zhangsan
1751438371472-0
name
zhangsan
127.0.0.1:6379>

3、xpending

xpending是 Redis Stream 数据结构中用于查询消费者组(Consumer Group)内待处理消息(Pending Entries List, PEL)的关键命令。其完整命令格式如下所示：

XPENDING key group [[IDLE min-idle-time] start end count [consumer]]

key: Stream 名称（必填）

group: 消费者组名称（必填）

[IDLE min-idle-time]: 筛选空闲时间超过指定毫秒数的消息

start end: 消息ID范围，支持特殊符号：

- 表示最小ID
+ 表示最大ID

count: 限制返回的消息数量

[consumer]: 指定只查看某个消费者的待处理消息

先看一个简单查询：

127.0.0.1:6379> xpending stream consumer_group 
5 #共有五条消息未被确认
1751425687108-0   # 最小消息id
1751438371472-0		# 最大消息id
kdyzm_consumer_1	#具体消费者
5					#kdyzm_consumer_1共有五条消息未确认

简单查询结果是一个简化的统计结果，如果我们想查询所有的未ACK的消息列表，可以使用如下命令：

127.0.0.1:6379> xpending stream consumer_group - + 10
1751425687108-0     #消息id
kdyzm_consumer_1    #消费者名称：当前持有该消息但未确认的消费者
1304133             #空闲时间（毫秒）：自该消息最后一次被交付给消费者后经过的时间（约 21.7 分钟）
1                   #投递次数：该消息被读取的次数。若大于 1，说明消息曾被多次重试或转移
1751436694812-0
kdyzm_consumer_1
1304133
1
1751438226276-0
kdyzm_consumer_1
1304133
1
1751438232352-0
kdyzm_consumer_1
1304133
1
1751438371472-0
kdyzm_consumer_1
1304133
1

4、xack

xack是 Redis Stream 数据结构中用于确认消息处理完成的关键命令，它属于消费者组(Consumer Group)功能的一部分，在非消费者组消费消息的场景下无法使用该命令。该命令完整格式如下所示：

xack key group ID [ID ...]

key：Stream 的名称（必填）

group：消费者组名称（必填）

ID [ID ...]：一个或多个需要确认的消息ID（必填）

xack命令返回值是一个整数，表示返回成功确认的消息数量。

xack工作原理： 当消费者通过 XREADGROUP 读取消息后，这些消息会被添加到 Pending Entries List (PEL) 中，表示"已读取但未确认"；XACK 命令会从消费者组的 PEL 中移除指定的消息ID，表示这些消息已被成功处理；确认后的消息会从 PEL 中删除，释放相关内存。

127.0.0.1:6379> xpending stream consumer_group - + 10  #查询出五条消息在PEL中
1751425687108-0
kdyzm_consumer_1
1671250
1
1751436694812-0
kdyzm_consumer_1
1671250
1
1751438226276-0
kdyzm_consumer_1
1671250
1
1751438232352-0
kdyzm_consumer_1
1671250
1
1751438371472-0
kdyzm_consumer_1
1671250
1
127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379> xack stream consumer_group 1751425687108-0 1751436694812-0 1751438226276-0 #手动ACK三条
3
127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379> xpending stream consumer_group - + 10 #再查还有两条消息在PEL中
1751438232352-0
kdyzm_consumer_1
1713880
1
1751438371472-0
kdyzm_consumer_1
1713880
1
127.0.0.1:6379>

5、xclaim

xclaim是 Redis Stream 消费者组功能中的一个重要命令，用于将待处理消息(Pending Entries List, PEL)的所有权从一个消费者转移到另一个消费者。该命令用于某些消息长时间未ACK需要消息重投的场景。命令的完整格式如下：

XCLAIM key group consumer min-idle-time ID [ID ...] [IDLE ms] [TIME ms-unix-time] [RETRYCOUNT count] [force] [justid]

key：Stream 的名称（必填）

group：消费者组名称（必填）

consumer：新的消费者名称（必填）

min-idle-time：消息最小空闲时间（毫秒），只有空闲时间超过此值的消息才会被转移

ID [ID ...]：一个或多个需要转移的消息ID（必填）

[IDLE ms]：设置消息的新空闲时间（毫秒），默认使用当前时间减去消息最后交付时间

[TIME ms-unix-time]：与IDLE相同，但使用绝对Unix时间戳（毫秒）

[RETRYCOUNT count]：设置消息的重试计数器，通常用于监控长时间未处理的消息

[force]：强制创建PEL条目，即使指定的ID尚未分配给任何消费者

[justid]：只返回成功转移的消息ID，不返回消息内容

127.0.0.1:6379> xpending stream consumer_group - + 10 #查询出两条在PEL中的消息都被kdyzm_consumer_1持有
1751438232352-0
kdyzm_consumer_1
1885915
1
1751438371472-0
kdyzm_consumer_1
1885915
1
127.0.0.1:6379> xclaim stream consumer_group kdyzm_consumer_2 0 1751438232352-0 #将第一条消息转移给kdyzm_consumer_2
1751438232352-0
name
zhangsan
127.0.0.1:6379> xpending stream consumer_group - + 10 #再次查询
1751438232352-0
kdyzm_consumer_2 #第一条消息被转移到了kdyzm_consuer_2
30169			#空闲时间被重置，从0开始重新计算
2				#投递次数变成了2
1751438371472-0
kdyzm_consumer_1
1984128
1

6、xinfo

xinfo是 Redis Stream 中用于获取流和消费者组相关信息的命令，它提供了多种子命令来查询 Stream 的内部状态。该命令的完整格式如下所示：

XINFO [CONSUMERS key groupname] [GROUPS key] [STREAM key] [HELP]

consumers子命令

consumers子命令用于查询指定消费者组中所有消费者的详细信息。

XINFO CONSUMERS <key> <groupname>

key: Stream 名称（必填）

groupname: 消费者组名称（必填）

127.0.0.1:6379> xinfo consumers stream consumer_group

127.0.0.1:6379>

groups子命令

groups子命令用于查询指定Stream的所有消费者组信息。

XINFO GROUPS <key>

key: Stream 名称（必填）

127.0.0.1:6379> xinfo groups stream
name
consumer_group
consumers
0
pending
0
last-delivered-id
0-0
127.0.0.1:6379>

stream子命令

stream子命令用于查询指定Stream的信息，包括长度、最后生成id等。

XINFO STREAM <key> [FULL [COUNT <count>]

key: Stream 名称（必填）

127.0.0.1:6379> xinfo stream stream
length
5
radix-tree-keys
1
radix-tree-nodes
2
last-generated-id
1751438371472-0
groups
1
first-entry
1751425687108-0
name
zhangsan
age
15
sex
man
last-entry
1751438371472-0
name
zhangsan
127.0.0.1:6379>

help子命令

help子命令用于查询xinfo命令的使用帮助信息。其输出如下：

127.0.0.1:6379> xinfo help
XINFO <subcommand> [<arg> [value] [opt] ...]. Subcommands are:
CONSUMERS <key> <groupname>
    Show consumers of <groupname>.
GROUPS <key>
    Show the stream consumer groups.
STREAM <key> [FULL [COUNT <count>]
    Show information about the stream.
HELP
    Prints this help.
127.0.0.1:6379>

7、消费者组综合练习

使用xadd命令创建一个Stream：kdyzm_stream并添加一条消息：

127.0.0.1:6379> xadd kdyzm_stream * name kdyzm
1751469707635-0

查看stream的长度：

127.0.0.1:6379> xlen kdyzm_stream 
1

创建一个消费者组kdyzm_consumer_group监听kdyzm_stream消息

127.0.0.1:6379> xgroup create kdyzm_stream kdyzm_consumer_group 0-0
OK

监听消息

127.0.0.1:6379> xreadgroup group kdyzm_consumer_group kdyzm_consumer_1 block 0 streams kdyzm_stream >
kdyzm_stream
1751469707635-0
name
kdyzm

使用>符号首次监听会接收到第一条消息。

使用xpending命令查看PEL中的数据

127.0.0.1:6379> xpending kdyzm_stream kdyzm_consumer_group - + 10
1751469707635-0
kdyzm_consumer_1
278229
3

使用xack命令确认下

127.0.0.1:6379> xack kdyzm_stream kdyzm_consumer_group 1751469707635-0
1

再次使用xpending命令查看PEL中的数据就已经看不到数据了。

接下来再创建一个消费者，共同监听kdyzm_stream

xreadgroup group kdyzm_consumer_group kdyzm_consumer_2 block 0 streams kdyzm_stream >

可以看到由于kdyzm_consume_1已经消费过第一条数据了，所以kdyzm_consumer_2就没有再重复消费，而是进行了一个阻塞行为。

接下来开三个窗口，两个消费者窗口，一个发送消息的窗口，演示Stream负载均衡发送和接受消息的场景。

第一个窗口运行命令：

xreadgroup group kdyzm_consumer_group kdyzm_consumer_1 block 0 streams kdyzm_stream >

使用kdyzm_consumer_group下的kdyzm_consumer_1消费者阻塞式监听kdyzm_stream

第二个窗口运行相似的命令，只是使用消费者kdyzm_consumer_2：

xreadgroup group kdyzm_consumer_group kdyzm_consumer_2 block 0 streams kdyzm_stream >

运行完两个命令，两个命令都会阻塞式监听，等待接收消息了。

第三个窗口发送命令发送消息数据

xadd kdyzm_stream * name zhangsan

然后查看消费者的行为：

可以看到Redis负载均衡将四次消息发送分别发送了给两个消费者各两次。

通过xpending命令能更直观的看到各个消费者未ack的情况：

127.0.0.1:6379> xpending kdyzm_stream kdyzm_consumer_group
4
1751521545678-0
1751521563585-0
kdyzm_consumer_1
2
kdyzm_consumer_2
2
127.0.0.1:6379> xpending kdyzm_stream kdyzm_consumer_group - + 100
1751521545678-0
kdyzm_consumer_1
677247
1
1751521551737-0
kdyzm_consumer_2
671188
1
1751521558157-0
kdyzm_consumer_1
664768
1
1751521563585-0
kdyzm_consumer_2
659340
1

接下来将这四个消息都ack掉：

127.0.0.1:6379> xack kdyzm_stream kdyzm_consumer_group 1751521545678-0 1751521551737-0 1751521558157-0 1751521563585-0
4

整个过程基本上就结束了。

END.

Redis（四）：Redis扩展类型Bitmap、HyperLogLog、GEO

Tue, 01 Jul 2025 22:37:50 +0800

在前面第一篇文章中介绍了redis中的string、hash、list、set、zset五种基本数据类型，除了这五种基本数据类型，还有位图(Bitmap)、基数估算(HyperLogLog)、地理位置(GEO)三种扩展数据类型。

一、位图Bitmap

Bitmap并非单独的一种数据类型，它操作的实际上还是string类型，只不过我们通过set/get命令操作的是整个字符串，而bitmap则操作字符串的某个二进制位，这样在只需要存储0或者1的状态的场景中，将会大大提高操作效率并且能更节省空间（节省空间不是绝对的，得看场景）。

我们已经知道位图底层其实就是一个 Redis 字符串，而 Redis 字符串的最大存储限制是 512 MB，这换算成字节数就是 512 * 1024 * 1024 = 536870912 字节 = 2^29 字节，换算成二进制位就是 2^29 * 8 = 2^32 位，这能满足任何状态存储需求了。

bitmap操作相关的命令如下所示：

命令	作用
`setbit key offset value`	对指定 key 的某一二进制位进行赋值，并返回该位置上原来的二进制值，初始值为0
`getbit key offset`	获取指定 key 上指定位置的二进制值，若超出当前位图范围，返回0
`bitcount key [start end]`	获取指定 key 中被设置为 1 的数量，可以通过 start 和 end 参数来指定区间，该数值是指字节数
`bitop operation destkey key [key ...]`	对一个或多个保存二进制位的字符串 key 进行位运算操作，并将结果保存到 destkey 上
`bitpos key bit [start] [end]`	获取指定 key 中被第一个二进制位为0或1的bit位，可以通过 start 和 end 参数来指定区间，该数值是指字节数。

在bitmap的命令中，offset是偏移量，指的是第几个bit，从0开始算起；start和end则是以字节为单位。

1、操作命令

setbit/getbit

setbit命令格式：setbit key offset value ，返回值是原bit的值。

getbit命令格式：getbit key offset

bitcount

bitcount命令格式：bitcount key [start end]

bitcount命令用于获取指定 key 中被设置为 1 的数量，可以通过 start 和 end 参数来指定区间，该数值是指字节数。

bitpos

bitpos是bit postion的简写。bitpos命令格式：bitpos key bit [start] [end] ，该命令用于获取指定 key 中被第一个二进制位为0或1的bit位，可以通过 start 和 end 参数来指定区间，该数值是指字节数。

key 表示键
bit 表示要目标二进制值是0还是1
start 表示指定区间的起始字节数
end 表示指定区间的终止字节数

bitop

bitop是bit operation的简写。bitop命令格式：bitop operation destkey key [key ...]，该命令对一个或多个保存二进制位的字符串 key 进行位运算操作，并将结果保存到 destkey 上。

operation 可以是 AND 、 OR 、 NOT 、 XOR 这四种操作中的任意一种：

BITOP AND destkey key [key ...] ，对一个或多个 key 求逻辑并，并将结果保存到destkey 。
BITOP OR destkey key [key ...] ，对一个或多个 key 求逻辑或，并将结果保存到 destkey。
BITOP XOR destkey key [key ...] ，对一个或多个 key 求逻辑异或，并将结果保存到destkey 。
BITOP NOT destkey key ，对给定 key 求逻辑非，并将结果保存到 destkey 。

除了 NOT 操作之外，其他操作都可以接受一个或多个 key 作为输入。

127.0.0.1:6379> setbit a 8 0
(integer) 0
127.0.0.1:6379> setbit b 8 1
(integer) 0
127.0.0.1:6379> bitop and a_b_and a b  #and操作
(integer) 2
127.0.0.1:6379> getbit a_b_and 8
(integer) 0
127.0.0.1:6379> bitop or a_b_or a b #or操作
(integer) 2
127.0.0.1:6379> getbit a_b_or 8
(integer) 1
127.0.0.1:6379> bitop xor a_b_xor a b #xor操作
(integer) 2
127.0.0.1:6379> getbit a_b_xor 8
(integer) 1
127.0.0.1:6379> bitop not a_not a #not操作
(integer) 2
127.0.0.1:6379> getbit a_not 8
(integer) 1

2、Bitmap优劣势分析

优势：

极低存储成本（1bit/状态）
O(1)时间复杂度的查询和设置

局限性：

仅支持二值状态，无法存储多值信息
稀疏数据（如少数位为1）可能浪费空间，此时集合更优

让我们分析一个命令setbit asdf 10000001 1，该命令浪费了大量内存空间：

内存预分配机制：Redis的Bitmap底层是字符串，当设置一个较大的偏移量时，Redis会预分配足够的内存来覆盖从偏移量0到目标偏移量的所有位。

稀疏数据问题：如果实际只有少数位被设置为1（例如仅第10000001 位），其余位默认填充0，这些未使用的0值仍会占用内存，导致内存利用率极低

可以通过命令查看asdf占用的存户空间：

127.0.0.1:6379> setbit asdf 10000001 1
(integer) 0
127.0.0.1:6379> memory usage asdf
(integer) 1310768
127.0.0.1:6379>

1310768字节等于1310768/1024/1024约等于1.25MB大小。

如何解决这个问题呢？

1、避免大偏移量初始化：连续偏移量设计，将用户ID或时间戳等标识符映射为连续整数（如从0开始），避免跳跃式偏移量。比如用户ID为150000000001时，可减去基准值（如150000000000），使偏移量变为1。

2、分区或分片：将大Bitmap拆分为多个小Bitmap。比如按天分片：SETBIT user:sign:20240630 1001 1；按用户范围分片：SETBIT segment:1 1001 1（用户ID 1-100万归到segment:1）。

3、使用其他数据结构：若数据极度稀疏（如仅有少量位为1），改用集合（Set）或哈希（Hash）可能更节省内存。

二、基数统计HyperLogLog

HyperLogLog是Redis提供的一种概率型数据结构，专门用于解决大规模数据集的基数统计（即唯一元素计数）问题。与传统方法相比，HyperLogLog能够在极低的内存消耗下（仅约12KB）提供接近线性的时间复杂度，使其成为大数据分析和实时统计领域的有力工具。

HyperLogLog具有以下几个显著特点：

极低内存消耗：无论统计多少元素，每个HyperLogLog键通常只占用约12KB内存（极端情况下最多64KB），可以统计高达2^64个元素的基数
固定误差率：标准误差率约为0.81%，对于大多数统计场景来说是可接受的
高效合并：支持多组HyperLogLog的合并去重（PFMERGE），时间复杂度为O(1)，适合分布式统计
自动去重：会忽略重复元素，多次添加同一元素不会影响结果
常数时间复杂度：插入(PFADD)和查询(PFCOUNT)操作都是O(1)复杂度

HyperLogLog算法比较复杂，但是使用起来比较简单，Redis提供了三个核心命令来操作HyperLogLog：

命令	作用
`pfadd key element [element ...]`	将一个或多个元素添加到指定的HyperLogLog结构中。
`pfcount key [key ...]`	查询一个或多个HyperLogLog的基数估算值。
`pfmerge destkey sourcekey [sourcekey ...]`	将一个或多个源HyperLogLog合并到目标HyperLogLog中，用于合并不同数据集的基数估算

pfadd / pfcount

pfadd key element [element ...]：将一个或多个元素添加到指定的HyperLogLog结构中。如果至少有一个元素是新添加的（即影响了基数估算），则返回1，否则返回0

pfcount key [key ...]：查询一个或多个HyperLogLog的基数估算值。当传入多个key时，返回的是这些HyperLogLog并集的基数估算值

pfmerge

pfmerge destkey sourcekey [sourcekey ...]：将一个或多个源HyperLogLog合并到目标HyperLogLog中，用于合并不同数据集的基数估算

三、GEO操作

Redis GEO 是 Redis 3.2 版本引入的地理空间数据处理功能，基于有序集合zset（Sorted Set）实现，支持存储经纬度坐标及高效的地理位置查询。

为了更好讲解geo各种命令，我们先准备好一组数据插入redis：

地点	坐标
北京	116.41,39.90
上海	121.47,31.23
青岛	120.31,36.06
石家庄	114.51,38.04
重庆	106.55,29.56
香港	114.17,22.28
澳门	116.41,39.91
连云港	119.22,34.60
乌鲁木齐	87.62,43.83
济南	117.12,36.65
郑州	113.66,34.75
太原	112.55,37.87
南京	118.80,32.06
武汉	114.30,30.59

注意，为了防止中文乱码，要使用./redis-cli --raw命令进入控制台，批量插入的命令为：

GEOADD cities:china 116.41 39.90 北京 121.47 31.23 上海 120.31 36.06 青岛 114.51 38.04 石家庄 106.55 29.56 重庆 114.17 22.28 香港 116.41 39.91 澳门 119.22 34.60 连云港 87.62 43.83 乌鲁木齐 117.12 36.65 济南 113.66 34.75 郑州 112.55 37.87 太原 118.80 32.06 南京 114.30 30.59 武汉

1、新增GEO数据：geoadd

geo新增命令是geoadd命令，geoadd命令完整格式如下：

geoadd key [NX|XX] [CH] longitude latitude member [longitude latitude member ...]

geoadd命令部分格式和zadd命令有些相似，zadd命令如下：

zadd key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]

两个命令中，[NX|XX]以及[CH]参数的意义是一样的。

可选参数[NX|XX]

NX：不存在则添加，否则忽略

XX：存在则更新分数，否则忽略

可选参数[CH]

CH参数的作用：返回值改为所有被修改的成员数量（包括新增和更新的成员）。zadd的默认行为是仅统计新添加的成员。

longitude latitude member

经度维度名字，比如 116.41 39.90 北京

举例：新增一条数据（116.41,39.9,北京），如果不存在则添加，否则忽略，返回值要统计被修改的成员数量，可以使用如下命令

127.0.0.1:6379> geoadd cities:china NX CH 116.41 39.9 北京
0
127.0.0.1:6379>

由于之前已经添加过了北京的geo数据，所以没有添加成功，返回了0。

2、查看GEO数据

查看zset数据

geoadd命令添加的数据在redis中是以zset形式存储的，geoadd 命令将经纬度坐标转换为 52 位整数作为 score 存储，同时将地点名称（如 "北京"）作为 member，所以没有直接查询geo数据的命令，可以使用zset相关命令直接查询geo数据。

127.0.0.1:6379> zrange cities:china 0 -1
乌鲁木齐
重庆
香港
武汉
上海
郑州
济南
南京
连云港
青岛
太原
石家庄
北京
澳门
127.0.0.1:6379>

注意，如果出现了中文乱码，一定要在redis-cli后加上--raw参数启动redis-cli。

geopos

geopos用于查询某地的经纬度，完整命令格式如下：

geopos key member [member ...]

比如查询北京的经纬度信息：

127.0.0.1:6379> geopos cities:china 北京
116.40999823808670044
39.90000009167092543
127.0.0.1:6379>

注意这里，redis并没有存储经纬度信息，geopos命令是通过动态解码score获得经纬度信息系的，所以这里产生了精度丢失。

geohash

Redis 的 GEOHASH 命令用于获取指定地理位置的 GeoHash 编码，这是一种将二维经纬度转换为一维字符串的算法，便于高效存储和查询地理位置数据，完整命令格式如下所示：

geohash key member [member ...]

member是地理位置名称，返回一个或多个成员的 Base32 编码字符串（长度通常为 11 字符），例如 "wx4fbzx4me0"。

127.0.0.1:6379> geohash cities:china 北京
wx4fbzx4me0
127.0.0.1:6379>

3、经纬度计算

接下来说一说geo命令中的经纬度计算相关的命令。

geodist

Redis 的 geodist 命令用于计算两个地理位置之间的直线距离（基于经纬度），支持多种单位（如米、千米、英里等），是 Redis GEO 地理信息功能的核心命令之一，其完整格式如下所示：

geodist key member1 member2 [m|km|ft|mi]

m：米
km：千米
mi：英里
ft：英尺

举个例子，计算北京和上海的直线距离：

127.0.0.1:6379> geodist cities:china 北京 上海 km
1066.9923
127.0.0.1:6379>

这个数据和官方给的数据1088差不多，有差距是因为我是在高德地图上随意选点和官方的计算方式不同导致的。

georadius

georadius 是 Redis 中用于查询指定经纬度为中心、半径范围内的地理位置成员的强大命令，适用于附近地点搜索、LBS 服务等场景。georadius命令已经不再被官方推荐使用，推荐使用geosearch命令替代。georadius命令完整格式如下所示：

georadius key longitude latitude radius m|km|ft|mi 
[WITHCOORD] 
[WITHDIST] 
[WITHHASH] 
[COUNT count [ANY]] 
[ASC|DESC] 
[STORE key] 
[STOREDIST key]

必选参数

key：存储地理位置的 Redis 键名。
longitude latitude：中心点的经度和纬度。
radius：搜索半径，需搭配单位：
- m：米
- km：千米
- ft：英尺
- mi：英里

可选参数

可选参数	作用
`WITHCOORD`	在返回结果中包含匹配位置的经纬度坐标
`WITHDIST`	在返回结果中包含匹配位置与中心点的距离
`WITHHASH`	返回位置元素经过原始geohash编码的有序集合分值(52位有符号整数)
`COUNT count [ANY]`	限制返回结果的数量。添加ANY选项时，命令会在找到足够结果后立即返回，可能不精确但更快
`ASC\|DESC`	结果排序方式，ASC表示从近到远，DESC表示从远到近。默认是ASC
`STORE key`	将返回结果的地理位置信息保存到指定key(以GeoHash值作为分数)
`STOREDIST key`	将返回结果离中心点的距离保存到指定key(以距离作为分数)

我查到临沂的坐标是（118.36,35.10），现在我以该坐标为中心，依次查询10km、100km、200km、300km范围内的城市：

127.0.0.1:6379> georadius cities:china 118.36 35.10 10 km

127.0.0.1:6379> georadius cities:china 118.36 35.10 100 km
连云港
127.0.0.1:6379> georadius cities:china 118.36 35.10 200 km
连云港
127.0.0.1:6379> georadius cities:china 118.36 35.10 300 km
连云港
青岛
济南
127.0.0.1:6379>

加上可选参数重新运行命令

127.0.0.1:6379> georadius cities:china 118.36 35.10 300 km withcoord withdist withhash count 3 desc 
青岛
206.1915          		#距离
4067544670361346		#score值
120.30999988317489624 	#经度
36.05999892411877994 	#纬度
济南
205.4495
4065935147208104
117.12000042200088501
36.65000089893579371
连云港
96.2017
4067136777713544
119.21999841928482056
34.59999953633954561

georadiusbymember

和georadius命令根据指定的坐标查询指定范围内的地点不同的是，georadiusbymember命令可以根据给定的成员位置来查找指定范围内的其他成员。完整的命令如下所示：

georadiusbymember key member radius m|km|ft|mi 
[WITHCOORD] 
[WITHDIST] 
[WITHHASH] 
[COUNT count [ANY]] 
[ASC|DESC] 
[STORE key] 
[STOREDIST key]

可选参数都和georadius一样，不再赘述。

127.0.0.1:6379> georadiusbymember cities:china 青岛 300 km withcoord withdist withhash desc
济南
293.1738 				#距离
4065935147208104		#score值
117.12000042200088501	#经度
36.65000089893579371	#纬度
连云港
190.1374
4067136777713544
119.21999841928482056
34.59999953633954561
青岛
0.0000
4067544670361346
120.30999988317489624
36.05999892411877994
127.0.0.1:6379>

geosearch

geosearch 是 Redis 6.2 版本新增的地理空间查询命令，用于在指定的地理空间索引中搜索符合条件的成员。该命令提供了比旧版 georadius 和 georadiusbymember 更强大和灵活的查询功能，支持圆形和矩形两种搜索范围，并且同时支持基于指定坐标以及指定地点的坐标的查询。完整的命令格式如下所示：

geosearch key 
[FROMMEMBER member] 
[FROMLONLAT longitude latitude] 
[BYRADIUS radius m|km|ft|mi] 
[BYBOX width height m|km|ft|mi] 
[ASC|DESC] 
[COUNT count [ANY]] 
[WITHCOORD] 
[WITHDIST] 
[WITHHASH]

虽然大多数的参数都是可选参数，但是实际上只是使用”geosearch key“命令直接查询会报错。可选参数大多数都必须"二选一"。

可选参数	作用
`FROMMEMBER member`	使用已存在于地理空间索引中的成员作为中心点
`FROMLONLAT longitude latitude`	直接指定经纬度作为中心点
`BYRADIUS radius m\|km\|ft\|mi`	圆形范围查询，指定半径和单位
`BYBOX width height m\|km\|ft\|mi`	矩形范围查询，指定宽度、高度和单位
`ASC\|DESC`	结果排序 ASC：按距离从近到远排序；DESC：按距离从远到近排序
`COUNT count [ANY]`	限制返回结果的数量，Any与COUNT配合使用，表示只要找到足够数量的匹配项就立即返回，不保证是最接近的结果，但能提高查询效率
`WITHCOORD`	返回匹配项的经度和纬度
`WITHDIST`	返回匹配项到指定中心点的距离
`WITHHASH`	以52位无符号整数的形式返回原始geohash编码（主要用于调试）

可以看到geosearch是个大而全的命令，功能上基本上等于georadius+georadiusbymember+矩形范围查询

还是以临沂市（118.36,35.10）为中心查询的例子，现在我以该坐标为中心，依次查询10km、100km、200km、300km范围内的城市：

127.0.0.1:6379> geosearch cities:china fromlonlat 118.36 35.10 byradius 10 km desc withcoord withdist withhash

127.0.0.1:6379> geosearch cities:china fromlonlat 118.36 35.10 byradius 100 km desc withcoord withdist withhash
连云港
96.2017
4067136777713544
119.21999841928482056
34.59999953633954561
127.0.0.1:6379> 
127.0.0.1:6379> geosearch cities:china fromlonlat 118.36 35.10 byradius 200 km desc withcoord withdist withhash
连云港
96.2017
4067136777713544
119.21999841928482056
34.59999953633954561
127.0.0.1:6379> geosearch cities:china fromlonlat 118.36 35.10 byradius 300 km desc withcoord withdist withhash
青岛
206.1915				#距离
4067544670361346		#score值
120.30999988317489624	#横坐标
36.05999892411877994	#纵坐标
济南
205.4495
4065935147208104
117.12000042200088501
36.65000089893579371
连云港
96.2017
4067136777713544
119.21999841928482056
34.59999953633954561
127.0.0.1:6379>

geosearchstore

geosearchstore 是 Redis 6.2 版本引入的地理空间命令，它结合了搜索和存储功能，允许用户执行地理空间搜索并将结果存储到一个新的键中。这个命令是 geosearch 命令的变体，主要区别在于它会将搜索结果保存到指定的目标键中。该命令的完整格式如下所示：

geosearchstore destination source 
[FROMMEMBER member] 
[FROMLONLAT longitude latitude] 
[BYRADIUS radius m|km|ft|mi] 
[BYBOX width height m|km|ft|mi] 
[ASC|DESC] 
[COUNT count [ANY]] 
[WITHCOORD] 
[WITHDIST] 
[WITHHASH] 
[STOREDIST]

可以看到geosearchstore命令的格式和geosearch的命令如出一辙。

接下来我将查询临沂市方圆300km范围的城市并将其保存到新的key new_cities。

127.0.0.1:6379> geosearchstore new_cities cities:china fromlonlat 118.36 35.10 byradius 300 km desc
3
127.0.0.1:6379> zrange new_cities 0 -1 withscores
济南
4065935147208104
连云港
4067136777713544
青岛
4067544670361346
127.0.0.1:6379> geopos new_cities 济南
117.12000042200088501
36.65000089893579371

注意，该命令在实践中发现并不能使用[WITHCOORD] 、[WITHDIST] 、[WITHHASH] 三个可选参数，使用之后会报错。

另外，STOREDIST可选参数的意思是将结果存储为 destination 键的 zset，并将距离作为分值（Score）。若不指定，默认存储 GeoHash 编码。

georadius_ro

georadius命令的只读版本，完整命令如下：

georadius_ro key arg arg arg arg ...options...

实际上可以等同于georadius命令删除store参数之后的版本：

georadius key longitude latitude radius m|km|ft|mi 
[WITHCOORD] 
[WITHDIST] 
[WITHHASH] 
[COUNT count [ANY]] 
[ASC|DESC]

但是因为没有了写操作，所以更安全。

127.0.0.1:6379> georadius_ro cities:china 118.36 35.10 300 km
连云港
青岛
济南
127.0.0.1:6379>

georadiusbymember_ro

georadiusbymember命令的只读版本，完整命令如下：

georadiusbymember_ro key arg arg arg ...options...

实际上等同于georadiusbymember命令删除store参数之后的版本：

georadiusbymember key member radius m|km|ft|mi 
[WITHCOORD] 
[WITHDIST] 
[WITHHASH] 
[COUNT count [ANY]] 
[ASC|DESC]

但是没有了写操作，所以更安全。

127.0.0.1:6379> georadiusbymember_ro cities:china 青岛 300 km desc
济南
连云港
青岛
127.0.0.1:6379>

END.

Redis（三）：Redis事务

Mon, 30 Jun 2025 14:15:52 +0800

我认为Redis的事务是一个很不完善的功能，甚至和“事务”的概念都不搭边，这里讲解Redis事务只是说它有这个东西，我想大概没有人在生产中用这个东西。

我们知道Mysql事务满足ACID特性，即原子性、一致性、隔离性、持久性，但是Redis事务并不满足ACID特性，如果Redis事务中的一条命令执行失败它会继续执行任务而且不会回滚。Redis事务实际上更像是打包好的批量脚本执行。

Redis事务涉及到以下命令的使用：

命令	作用
`multi`	标记一个事务块的开始。
`exec`	执行所有事务块内的命令。
`discard`	取消事务，放弃执行事务块内的所有命令。
`watch key [key ...]`	监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
`unwatch`	取消 WATCH 命令对所有 key 的监视。

先看一个比较正常的执行流程：使用multi命令和exec命令批量执行命令。

那么watch命令是怎么用的呢？假设有个string类型的变量a为1，接下来要开启一个事务，事务内依赖变量a，如果变量a发生了变化则可能导致事务执行结果异常，这时候就要"watch" a ,防止在事务执行的过程中有其他客户端改变了a的值；如果发现a的值发生了变化，就要停止事务的执行：

discard命令是可以在事务内执行的命令，执行后会退出事务。

好了，redis事务比较简单，由于其功能并不完善，所以建议别用。

END.

Redis（二）：Redis发布订阅模式

Mon, 30 Jun 2025 11:17:11 +0800

使用Redis实现消息队列有两种方式：list队列模式以及发布订阅模式。

一、list队列模式

1、list队列的原理

在上一篇文章《Redis（一）：Redis数据类型和常用命令》中已经详细讲解了Redis中list相关的操作。list底层是个双向链表，头部和尾部的操作效率非常高，其操作命令也符合队列API的行为方式。我们在使用list作为消息队列的时候，会使用lpush命令将消息放入队列，使用rpop命令将消息出队列。

需要注意的是rpop命令是一次性命令，它在执行前并不知道消息队列中是否有消息，可以预料到的是，如果队列中一直没有消息，只能通过rpop命令一直轮询。为了解决这个问题，可以使用brpop命令:

brpop key [key ...] timeout

brpop命令中的timeout参数是必传的，当它为0的时候表示无限期阻塞等待；不为零的时候计时结束就会自动放弃阻塞等待。

brpop命令返回值有两个值，第一个值是key的名字，第二个值是弹出的元素值，如果从队列中取不出来数据，会一直阻塞，在一定范围内没有取出则返回null。需要注意brpop命令并不会阻塞主线程，brpop虽然是个阻塞命令，但是它会通过如下机制避免阻塞主线程：

非忙等待：当 BRPOP 监听列表为空时，Redis 会将客户端连接标记为“阻塞状态”，并将其从活跃客户端列表中移除，主线程不会持续轮询或等待，而是继续处理其他请求
事件驱动：Redis 使用事件循环（如 epoll）管理客户端连接。阻塞的客户端会被挂起，直到目标列表有新元素插入时，Redis 通过事件回调唤醒对应的客户端连接

2、list队列演示

第一步：进入容器

我在6.2.1版本的redis下做个演示。由于我使用了docker，所以需要先进入我的redis容器（容器名为redis）：

docker exec -it redis /bin/bash

然后进入redis-cli命令所在的目录：

cd /usr/local/bin

运行redis-cli命令：

./redis-cli

进入redis交互命令行，执行auth命令做个认证：

auth 123456

依照此步骤打开三个会话页面：

第二步：发送/接收消息

三个会话中，第一个会话用于向队列发送消息，第二个和第三个会话使用brpop命令接收消息。

可以看到，brpop命令即使key不存在，也可以持续监听，并且当key被创建而且list中有值时会自动将值取出来。多个监听者可以同时监听同一个消息队列，但是同一个值只能被一个监听者获取到。

二、发布订阅模式

1、发布订阅模式简介

发布订阅模式和rabbitmq消息队列的topic模式很像，多个客户端订阅同一个channel，channel发布消息的时候，每个客户端都能收到相同的消息。

消息订阅命令：subscribe channel [channel ...],也就是说该命令可以订阅多个channel。

消息发送命令：publish channel message该命令只能向一个channel发送命令。

全部命令如下所示：

命令	描述
`publish channel message`	将信息发送到指定的频道。
`subscribe channel [channel ...]`	订阅给定的一个或多个频道的信息。
`pubsub subcommand [argument [argument ...]]`	查看订阅与发布系统状态。 `PUBSUB CHANNELS`：列出当前活跃的频道 `PUBSUB NUMSUB [channel ...]`：返回指定频道的订阅者数量
`unsubscribe [channel [channel ...]]`	指退订给定的频道。目前还不知道如何在redis-cli中执行该命令，因为ctrl+c就已经实现退订了。
`psubscribe pattern [pattern ...]`	订阅一个或多个符合给定模式的频道。
`punsubscribe [pattern [pattern ...]]`	退订所有给定模式的频道。

2、发布订阅模式演示

接下来打开三个客户端，一个用于发布，另外两个用来订阅。

3、发布订阅模式分析

发布订阅模式的优点：发布者和订阅者不需要知道彼此的存在，功能解耦。

发布订阅模式的缺点：

消息没有持久化，如果消费者断线重连，消息会丢失
没有ack机制，无法保证消息被成功消费。
Redis服务重启后消息会丢失。

综合来看，redis在消息队列方面功能并不完善，如果需要用到消息队列，最好使用专业的消息队列中间件，比如rabbitmq、kafka等。

当然，redis5中引入了Stream，Stream做了数据的持久化处理，一定方面弥补了发布订阅模式的缺点。。。建议还是不要用。

Redis（一）：Redis数据类型和常用命令

Fri, 27 Jun 2025 15:32:44 +0800

上一篇文章《CentOS安装Redis》已经安装好了Redis，本篇文章将讲解Redis的基本使用以及五种数据类型。

注意：本篇文章使用的redis版本是6.2.1，到今天为止，redis8.0已经GA了，但是实际上基础使用命令差别不大。

一、常用命令

1、redis命令行

REDIS是一种NoSQL数据库，它和MySQL数据库一样，都有和Server端交互的命令行工具，而且在这个命令行工具下，还有非常友好的命令提示。

我安装的是docker版本的redis，可以先使用命令docker exec -it 容器名 /bin/bash进入容器，然后打开/usr/local/bin目录，就可以看到redis安装后提供的相关工具了

直接运行./redis-cli就可以进入命令行

2、认证命令auth

进入命令行以后，如果redis设置了密码，则直接运行相关的命令会提示报错，需要先执行auth命令认证，auth命令的格式如下：

AUTH [username] password

username可选。

3、查看信息命令info

info是个很有用的命令，可以使用该命令查看当前运行的redis server的所有状态，包括：redis server的版本号、CPU信息、内存信息、持久化信息、数据库信息等等

info [section]

使用info命令默认显示如下：

# Server
redis_version:6.2.1
redis_git_sha1:00000000
redis_git_dirty:0
......

# Clients
connected_clients:2
cluster_connections:0
maxclients:10000
......

# Memory
used_memory:894792
used_memory_human:873.82K
used_memory_rss:10809344
......

# Persistence
loading:0
current_cow_size:0
current_fork_perc:0.00%
......

# Stats
total_connections_received:3
total_commands_processed:283
instantaneous_ops_per_sec:0
......

# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
......

# CPU
used_cpu_sys:4.598728
used_cpu_user:4.760232
used_cpu_sys_children:0.003479
......

# Modules

# Errorstats
errorstat_ERR:count=1
errorstat_NOAUTH:count=2

# Cluster
cluster_enabled:0

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

info命令的输出很长，而且输出是带注释的，注释中的内容表示“模块名”，共分为10个模块，info [section]中的section正是模块名：

模块	查询命令	作用
Server	info server	提供Redis服务器基本信息，如版本号、运行时间、操作系统、进程ID、配置文件路径等。
Clients	info clients	显示客户端连接状态，包括连接数、阻塞客户端数量、输入/输出缓冲区大小等。
Memory	info memory	展示内存使用详情，包括已用内存、内存碎片率、峰值内存、分配器等，用于监控内存优化。
Persistence	info persistence	记录RDB和AOF持久化状态，如最近保存时间、后台操作状态、AOF重写进度等。
Stats	info stats	统计命令处理数量、连接数、键过期/驱逐情况、每秒操作数等性能指标。
Replication	info replication	主从复制信息，包括角色（master/slave）、从节点列表、复制偏移量、延迟等。
CPU	info cpu	统计CPU消耗，包括用户态和系统态时间、子进程CPU占用等。
Modules	info modules	用于查看当前 Redis 服务器加载的模块信息
Cluster	info cluster	显示集群状态，如节点信息、槽分配情况（仅集群模式有效）。
Keyspace	info keyspace	统计各数据库的键数量、过期键数量及平均TTL。

4、切换数据库命令select

redis数据库默认有16个，编号从0到15，对redis的读写操作实际上是针对某个redis库的读写操作，使用select命令切换使用的数据库：

select index

index是从0到15的整数。

在redis-cli下，在没有选择数据库的情况下，默认读写操作都是在数据库0下操作的：

使用select命令选择非0的数据库之后，将会在命令行中显示当前使用的数据库：

另外，可以使用client info命令更直观的看到当前链接使用的客户端信息（包含使用的数据库）

5、客户端管理命令client

client命令用于查看和管理连接到redis server的客户端信息。

client list

列出当前所有连接到 Redis 的客户端信息：

CLIENT LIST

主要输出字段及说明：

字段	说明
`id`	客户端唯一 ID
`addr`	客户端 IP 和端口
`name`	客户端名称（可自定义）
`db`	当前使用的数据库编号
`age`	连接已建立时间（秒）
`idle`	空闲时间（秒）
`flags`	连接类型（`N`=普通客户端，`M`=主节点，`S`=从节点等）
`cmd`	最近执行的命令

client info

查看当前连接到Redis的客户端信息，其输出格式和client list命令一样，但是只显示当前连接的客户端信息。

client setname

为当前连接设置一个易读的名称，方便管理：

client setname kdyzm-connection

client getname

查看当前连接的客户端名称。

client kill

该命令用于终止某个客户端的连接，完整命令格式如下：

client kill [ip:port] [ID client-id] [TYPE normal|master|slave|pubsub] [USER username] [ADDR ip:port] [SKIPME yes/no]

从命令格式中就可以看得出，该命令可以通过多种方式终止客户端的连接。

比如想终止id为5的连接，可以使用命令client kill id 5

6、数据清理命令

命令	作用
`flushdb [ASYNC\|SYNC]`	删除当前数据库的所有键
`flushall [ASYNC\|SYNC]`	删除所有数据库的所有键

这两个命令往往会触发安全策略被禁止执行。

二、五种数据类型

Redis的存储是以Key-Value形式存储的，value有五种类型：string、hash、list、set、zset 以应对不同数据格式的存储。

1、string

String类型是最简单的数据类型，它的值是字符串类型或者数字类型。

赋值

命令	作用
`SET key value`	设置指定 key 的值。
`MSET key value [key value ...]`	同时设置一个或多个 key-value 对。
`APPEND key value`	APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾，返回值是追加后字符串长度
`SETNX key value`	仅当不存在时赋值，使用该命令可以实现【分布式锁】的功能

查询

命令	作用
`GET key`	查询指定 key 的值。
`MGET key [key ...]`	同时获取一个或多个key值
`STRLEN key`	返回键值的长度，如果键不存在则返回0
`GETRANGE key start end`	获取key值的子串，坐标从0开始，start到end为闭区间；end为-1表示最后一个字符

更新

命令	作用
`GETSET key value`	为key设置新值value，并返回旧值
`INCR key`	自增命令。当value为整数数据时，才能使用该命令，该命令是原子操作，返回值是自增后的新值
`INCRBY key increment`	增加increment命令。当value为整数数据时，才能使用该命令，该命令是原子操作，返回值是增加后的新值
`DECR key`	自减命令。当value为整数数据时，才能使用该命令，该命令是原子操作，返回值是自减后的新值
`DECRBY key decrement`	减少decrement命令。当value为整数数据时，才能使用该命令，该命令是原子操作，返回值是减少后的新值

2、hash

hash 类型也叫散列类型，它提供了字段和字段值的映射。字段值只能是字符串类型，不支持散列类型、集合类型等其它类型，它的数据结构和java中的Map或者Python中的字典比较像，hash 特别适合用于存储对象。

赋值

命令	作用
`hset key field value [field value ...]`	设置多个属性值，例如`hset user name zhangsan age 14`，返回值是一个整数表示新增的字段数量
`hmset key field value [field value ...]`	设置多个属性值，返回值为成功或者失败；新版本已经不推荐使用该方法设置了，推荐使用hset。
`hsetnx key field value`	类似 HSET ，区别在于如果字段存在，该命令不执行任何操作。

查询

命令	作用
`hget key field`	获取一个字段值，例如：`hget user name`
`hmget key field [field ...]`	获取多个字段值，例如：`hmget user name age`
`hgetall key`	获取所有字段值，例如：`hgetall user`
`hexists key field`	判断某个属性是否存在
`hkeys key`	获取所有属性
`hvals key`	获取所有值
`hlen key`	获取字段数量

更新

命令	作用
`hdel key field [field ...]`	删除key的属性字段注意并非删除key，删除key应当使用通用的del命令。
`hincrby key field increment`	增加increment命令。当属性值为整数数据时，才能使用该命令，该命令是原子操作，返回值是增加后的新值
`hincrbyfloat key field increment`	增加increment命令。当属性值为数字类型时，才能使用该命令，该命令是原子操作，返回值是增加后的新值相对于hincrby，它支持浮点数的运算，但是可能存在精度丢失的问题。

3、list

redis中的list可以存储一个有序的字符串列表，它的内部是一个双向链表所以向列表两端添加元素的时间复杂度为0(1) ，获取越接近两端的元素速度就越快。基于此特性，list数据类型可被用于消息队列操作。

入队出队

命令	作用
`lpush key element [element ...]`	从左侧入队。比如`lpush list 1 2 3` 实际上在list中存储的顺序是3 2 1
`rpush key element [element ...]`	从右侧入队。比如`rpush list 1 2 3`实际上在list中存储的也是1 2 3
`lpop key [count]`	左侧弹出一个元素或者count个元素。
`rpop key [count]`	右侧弹出一个元素或者count个元素。

更新

命令	作用
`lrem key count element`	删除列表中指定个数的值。 LREM 命令会删除列表中前 count 个值为 value 的元素，返回实际删除的元素个数。根据 count 值的不同，该命令的执行方式会有所不同：当count>0时， LREM会从列表左边开始删除。当count<0时， LREM会从列表后边开始删除。当count=0时， LREM删除所有值为value的元素。
`lset key index element`	设置index下标（正向）的数组值为element
`linsert key BEFORE\|AFTER pivot element`	向列表中插入元素。该命令首先会在列表中从左到右查找值为pivot的元素，然后根据第二个参数是BEFORE还是AFTER来决定将value插入到该元素的前面还是后面。
`ltrim key start stop`	只保留列表指定片段,指定范围和LRANGE一致
`rpoplpush source destination`	将source的最后一个元素转移到destination的头部

查询

命令	作用
`lrange key start stop`	查询指定范围（闭区间）的元素列表
`lindex key index`	查询指定元素下标的值
`llen key`	查询列表元素长度

4、set

set 类型即集合类型，其中的数据是不重复且没有顺序。

集合类型的常用操作是向集合中加入或删除元素、判断某个元素是否存在等，由于集合类型的 Redis 内部是使用值为空的散列表实现，所有这些操作的时间复杂度都为 0(1) 。

Redis 还提供了多个集合之间的交集、并集、差集的运算。

基础命令

命令	作用
`sadd key member [member ...]`	向集合中添加元素
`srem key member [member ...]`	从集合中移除元素
`smembers key`	获得集合中的所有元素
`sismember key member`	判断元素是否在集合中
`scard key`	获得集合中元素的个数
`spop key [count]`	随机从集合中移除count个元素

集合运算

假设我们有A集合{1,2,3}和B集合{3,4,5}

命令	作用
`sdiff key [key ...]`	取差集。 `sdiff A B`相当于A-B，结果为{1,2}
`sinter key [key ...]`	取交集。 `sinter A B`相当于A∩B，结果为{3}
`sunion key [key ...]`	取并集。 `suion A B`相当于A∪B，结果为{1,2,3,4,5}

5、zset

zet又称为sorted set，即有序集合，它是在 set 集合类型的基础上，为集合中的每个元素都关联一个分数，这使得我们不仅可以完成插入、删除和判断元素是否存在在集合中，还能够获得分数最高或最低的前N个元素、获取指定分数范围内的元素等与分数有关的操作。在某些方面有序集合和列表类型有些相似：

二者都是有序的。
二者都可以获得某一范围的元素。

但是，二者有着很大区别：

列表类型是通过链表实现的，获取靠近两端的数据速度极快，而当元素增多后，访问中间数据的速度会变慢。
有序集合类型使用散列表实现，所有即使读取位于中间部分的数据也很快。
列表中不能简单的调整某个元素的位置，但是有序集合可以（通过更改分数实现）
有序集合要比列表类型更耗内存。

zadd命令

zadd命令用于向有序集合中新增或更新元素，它是有序集合中最重要的一个命令，其格式如下所示：

zadd key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]

可以看到它有很多可选参数，这导致该命令比较复杂。

基础使用命令

刨除可选参数，zadd的基础命令就是

zadd key score member [score member ...]

注意，分数在前，元素在后。

127.0.0.1:6379> zadd scoreboard 80 zhangsan 89 lisi 94 wangwu
(integer) 3

可选参数[NX|XX]

NX：不存在则添加，否则忽略

XX：存在则更新分数，否则忽略

127.0.0.1:6379> zadd z nx 90 zhangsan   #zhangsan不存在则新增
(integer) 1
127.0.0.1:6379> zadd z nx 90 zhangsan   #zhangsan已存在则忽略
(integer) 0
127.0.0.1:6379> zadd z xx 80 lisi       #lisi不存在则忽略
(integer) 0
127.0.0.1:6379> zadd z xx 80 zhangsan   #lisi已存在则更新
(integer) 0
127.0.0.1:6379> 
127.0.0.1:6379> 
127.0.0.1:6379> zrange z 0 -1 withscores
1) "zhangsan"
2) "80"

可选参数[GT|LT]

GT：当新分数大于原分数时才更新

LT：新分数小于原分数时才更新

127.0.0.1:6379> zrange z 0 -1 withscores
1) "zhangsan"
2) "80"
127.0.0.1:6379> zadd z GT 79 zhangsan   # zhangsan新分数79大于原分数80才更新，所以没更新
(integer) 0
127.0.0.1:6379> zrange z 0 -1 withscores
1) "zhangsan"
2) "80"
127.0.0.1:6379> zadd z GT 81 zhangsan  # zhangsan新分数81大于原分数80才更新，所以更新了
(integer) 0
127.0.0.1:6379> zrange z 0 -1 withscores
1) "zhangsan"
2) "81"

可选参数[CH]

CH参数的作用：返回值改为所有被修改的成员数量（包括新增和更新的成员）。zadd的默认行为是仅统计新添加的成员。

127.0.0.1:6379> zrange z 0 -1 withscores
1) "zhangsan"
2) "90"
127.0.0.1:6379> zadd z 91 zhangsan   #修改了zhangsan的分数为91但是返回0
(integer) 0
127.0.0.1:6379> zadd z CH 91 zhangsan #虽然加了CH参数，但是新旧分数都一样都是91所以并没有执行修改动作
(integer) 0
127.0.0.1:6379> zadd z CH 92 zhangsan #加了CH参数，新分数92修改后返回了影响行数
(integer) 1

可选参数INCR

将成员的分数累加指定值（类似 ZINCRBY），此时只能操作一个成员。返回值是更新后的分数值。建议使用zincrby。

127.0.0.1:6379> zrange z 0 -1 withscores
1) "zhangsan"
2) "95"
127.0.0.1:6379> zadd z incr 3 zhangsan #zhangsan增加3
"98"

更新

命令	作用
`zincrby key increment member`	有序集合中对指定成员的分数加上增量 increment
`zrem key member [member ...]`	移除有序集合中的一个或多个成员
`zremrangebyscore key min max`	根据分值范围删除范围内的所有成员
`zremrangebylex key min max`	移除有序集合中给定的字典区间的所有成员
`zremrangebyrank key start stop`	移除有序集合中给定的排名区间的所有成员

查询

命令	作用
`zrange key min max [BYSCOREBYLEX] [REV] [LIMIT offset count] [WITHSCORES]`	获取索引在min和max之间的成员。比如`zrange z 0 -1 withscores`命令将查询z集合的全部成员。
`zcard key`	获取有序集合的成员数
`zcount key min max`	计算在有序集合中指定区间分数的成员数
`zrangebyscore key min max [WITHSCORES] [LIMIT offset count]`	通过分数返回有序集合指定区间内的成员
`zrank key member`	查询member的索引
`zscore key member`	查询成员分值

集合运算

命令	作用
`zdiff numkeys key [key ...] [WITHSCORES]`	求差集
`zinter numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM\|MIN\|MAX] [WITHSCORES]`	求交集
`zunion numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM\|MIN\|MAX] [WITHSCORES]`	求并集
`zdiffstore destination numkeys key [key ...]`	求差集并将结果存入有序集合destination
`zinterstore destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM\|MIN\|MAX]`	求交集并将结果存入有序集合destination
`zunionstore destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM\|MIN\|MAX]`	求并集并将结果存入有序集合destination

三、key操作命令

以上五种数据类型都没有介绍删除命令，因为它们都使用统一的key删除命令。

1、常见命令

以下是常见的key命令：

命令	作用
`del key [key ...]`	删除一个或多个key
`exists key [key ...]`	判断一个key或者多个key是否存在
`expire key seconds`	为key设置过期时间，单位秒
`keys pattern`	查询指定模式的key列表，比如常见的`keys *`查询所有key，注意该命令可能会导致redis server被阻塞。
`move key db`	将key移动到别的db
`persist key`	移除key的过期时间，key将持久保存
`ttl key`	以秒为单位返回key的剩余有效期事件，有效期过后key将被删除
`pttl key`	以毫秒为单位返回key的剩余有效期事件，有效期过后key将被删除
`rename key newkey`	将key重命名
`renamenx key newkey`	在newkey不存在的情况下将key重命名为newkey
`type key`	查询某个key的类型

除了以上常见命令，还有一个比较重要的常见命令scan。

2、scan命令

Redis 的 SCAN 命令是一种**非阻塞式、渐进式遍历键空间（key space）**的迭代器命令，用于替代阻塞式的 KEYS 命令，特别适合生产环境中处理大数据量的键遍历需求。

scan命令格式如下：

scan cursor [MATCH pattern] [COUNT count] [TYPE type]

cursor：游标值，初始为 0，每次调用返回新的游标，直到返回 0 表示遍历完成

MATCH pattern（可选）：通配符模式匹配键名（如 user:* 匹配以 user: 开头的键）

COUNT count（可选）：提示每次迭代返回的键数量（默认约 10 个，实际可能浮动）

TYPE type（Redis 6.0+）：按数据类型过滤（如 string、hash 等）

来看一个例子。

现在我有如下keys

127.0.0.1:6379> keys *
1) "c"
2) "g"
3) "d"
4) "f"
5) "a"
6) "e"
7) "h"
8) "b"
127.0.0.1:6379>

我要用scan命令来遍历它：

127.0.0.1:6379> scan 0 match * count 1 type string #初始从0开始遍历
1) "4"				#下一个游标是4
2) 1) "c"			#本次返回的结果是c
127.0.0.1:6379> scan 4 match * count 1 type string #从4开始下一个迭代查询
1) "2"				#下一个游标是2
2) 1) "h"			#本次返回两个值：h、b
   2) "b"
127.0.0.1:6379> scan 2 match * count 1 type string
1) "6"
2) 1) "g"
   2) "d"
127.0.0.1:6379> scan 6 match * count 1 type string
1) "7"
2) 1) "f"
   2) "a"
   3) "e"
127.0.0.1:6379> scan 7 match * count 1 type string
1) "0"
2) (empty array)

注意，虽然指定了每次返回的数量是1，但是返回的数量大部分并不是1，似乎count参数设置的并没有生效：这是因为COUNT 不保证精确性，它是性能优化的提示，非强制限制。SCAN 使用高位进位加法遍历哈希槽，避免因扩容/缩容遗漏数据。此算法可能导致单次遍历多个槽位，从而返回更多元素。

scan命令只用于key的遍历，对于么比如hash、set、zset类型的，它们本身也是可以遍历的，所以还有scan的变种命令：

命令	作用
`hscan key cursor [MATCH pattern] [COUNT count]`	hash类型的key遍历
`sscan key cursor [MATCH pattern] [COUNT count]`	set类型的key遍历
`zscan key cursor [MATCH pattern] [COUNT count]`	zset类型的key遍历

SpringBoot集成TOTP双因素认证（2FA）实战

Tue, 17 Jun 2025 17:38:54 +0800

一、双因素认证的概念

双因素认证（2FA，Two Factor Authentication）又称双因子认证、两步验证，指的是是一种安全认证过程，需要用户提供两种不同类型的认证因子来表明自己的身份，包括密码、指纹、短信验证码、智能卡、生物识别等多种因素组合，从而提高用户账户的安全性和可靠性。

2FA认证流程如下：

用户登录应用程序。
用户输入登录凭证，通常是账号和密码，做初始身份验证。
验证成功后，提示用户提交第二个身份验证因子。
用户将第二个身份验证因子输入至应用程序，如果第二个身份验证因子通过，用户将通过身份验证并被授予对应的系统操作权限。

举个简单的例子，我们使用账号密码登录微博、豆瓣等应用时，命名账号密码都对了，但是还要输入手机验证码二次验证以确保安全性，这就是双因素验证。

虽然短信验证码实现简单，但是在实际场景中，一般会使用其它2FA方式替代：一则短信发送会产生费用，二则它也不是那么安全，它容易被拦截和伪造，SIM 卡也可以克隆。

一般来说，安全的双因素认证不是密码 + 短消息，而是密码+ TOTP。

二、TOTP

TOTP 的全称是"基于时间的一次性密码"（Time-based One-time Password）。它是公认的可靠解决方案，已经写入国际标准 RFC6238。

1、TOTP步骤

第一步，用户开启双因素认证后，服务器生成一个密钥。

第二步：服务器提示用户扫描二维码（或者使用其他方式），把密钥保存到用户的手机。也就是说，服务器和用户的手机，现在都有了同一把密钥。

注意，密钥必须跟手机绑定。一旦用户更换手机，就必须生成全新的密钥。

第三步，用户登录时，手机客户端使用这个密钥和当前时间戳，生成一个哈希，有效期默认为30秒。用户在有效期内，把这个哈希提交给服务器。

第四步，服务器也使用密钥和当前时间戳，生成一个哈希，跟用户提交的哈希比对。只要两者不一致，就拒绝登录。

2、TOTP原理

仔细看上面的步骤，你可能会有一个问题：手机客户端和服务器，如何保证30秒期间都得到同一个哈希呢？

答案就是下面的公式。

TC = floor((unixtime(now) − unixtime(T0)) / TS)

上面的公式中，TC 表示一个时间计数器，unixtime(now)是当前 Unix 时间戳，unixtime(T0)是约定的起始时间点的时间戳，默认是0，也就是1970年1月1日。TS 则是哈希有效期的时间长度，默认是30秒。因此，上面的公式就变成下面的形式。

TC = floor(unixtime(now) / 30)

所以，只要在 30 秒以内，TC 的值都是一样的。前提是服务器和手机的时间必须同步。

接下来，就可以算出哈希了。

TOTP = HASH(SecretKey, TC)

上面代码中，HASH就是约定的哈希函数，默认是 SHA-1。

接下来在SpringBoot中集成TOTP实现双因素认证。

三、TOTP双因素认证实战

1、开源项目：GoogleAuth

TOTP自己手写还是稍稍有些复杂，去网上找了开源项目，发现一个比较好的实现：GoogleAuth，使用时需要引入Maven依赖：

<dependency>
    <groupId>com.warrenstrange</groupId>
    <artifactId>googleauth</artifactId>
    <version>1.5.0</version>
</dependency>

为了生成图片二维码，还需要引入：

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <zxing.version>3.4.0</zxing.version>
</properties>
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>${zxing.version}</version>
</dependency>
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>javase</artifactId>
    <version>${zxing.version}</version>
</dependency>

GoogleAuth的API比较简单，常见API如下：

生成secret

/**
 * 测试获取秘钥
 */
@Test
public void testGetKey() {
    GoogleAuthenticator gAuth = new GoogleAuthenticator();
    final GoogleAuthenticatorKey key = gAuth.createCredentials();
    String key1 = key.getKey();
    log.info(key1);
}

生成一次性验证码

/**
 * 测试生成一次性验证码
 */
@Test
public void testGetTotpPassword() {
    GoogleAuthenticator gAuth = new GoogleAuthenticator();
    int code = gAuth.getTotpPassword("PWTBUDW6OAPV6E2EVMBHX2X7LH6MXRNE");
    log.info("{}", code);
}

验证码验证

/**
 * 测试秘钥验证
 */
@Test
public void testAuthorize() {
    GoogleAuthenticatorConfig config = new GoogleAuthenticatorConfig
            .GoogleAuthenticatorConfigBuilder()
            //设置容忍度最小
            .setWindowSize(1)
            .build();
    GoogleAuthenticator gAuth = new GoogleAuthenticator(config);
    int verificationCode = 448247;
    String secretKey = "6VRFLPHNPQ4P2WAQWEIYPCQ43KIHVCJO";
    boolean isCodeValid = gAuth.authorize(secretKey, verificationCode);
    if (isCodeValid) {
        log.info("匹配");
    } else {
        log.info("不匹配");
    }
}

获取二维码（图片链接格式）

/**
 * 获取图片二维码
 */
@Test
public void testGetOtpAuthURL() {
    GoogleAuthenticator gAuth = new GoogleAuthenticator();
    final GoogleAuthenticatorKey key = gAuth.createCredentials();
    log.info(key.getKey());
    String otpAuthURL = GoogleAuthenticatorQRGenerator.getOtpAuthURL(
            ISSUER,
            userName,
            key
    );
    log.info(otpAuthURL);
}

获取二维码（字节流）

@Test
public void testGetOtpAuthQrByteArrayOutputStream() throws WriterException, IOException {
    GoogleAuthenticator gAuth = new GoogleAuthenticator();
    final GoogleAuthenticatorKey key = gAuth.createCredentials();
    String otpAuthUri = GoogleAuthenticatorQRGenerator.getOtpAuthTotpURL(
            ISSUER,
            userName,
            key);

    QRCodeWriter qrWriter = new QRCodeWriter();
    BitMatrix bitMatrix = qrWriter.encode(otpAuthUri, BarcodeFormat.QR_CODE, 200, 200);
    BufferedImage bufferedImage = MatrixToImageWriter.toBufferedImage(bitMatrix);
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    ImageIO.write(bufferedImage, "png", outputStream);
    ImageIO.write(bufferedImage, "png", new File("temp.png"));
}

2、开源项目：光年Admin模板

为了能更直观的展示TOTP功能集成到SpringBoot的样子，我决定基于开源项目 Light Year Admin v5 去做前端的开发。Light Year Admin v5 是一个管理端模板，基于Bootstrap 5.1.3。线上体验地址：http://lyear.itshubao.com/v5/ ，也可以下载下来以后使用http-server快速启动查看效果：

该项目是一个纯前端项目，为了更方便的集成到SpringBoot，我将其集成到了freemarker：

3、项目实战：2fa-demo

项目地址：https://gitee.com/kdyzm/2fa-demo

该项目依赖于MySQL，所以在运行前需要先准备好MySQL环境。

运行前准备

需要创建Mysql数据库，运行如下脚本：

CREATE DATABASE `2fa_demo` ;
USE `2fa_demo`;

CREATE TABLE `sys_user` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_name` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户名',
  `nick_name` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户昵称',
  `password` varchar(64) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户密码',
  `two_fa_secret` varchar(64) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '两步验证的秘钥',
  `tow_fa_enabled` tinyint(1) DEFAULT '0' COMMENT '是否启用两步验证',
  `create_by` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT 'sys' COMMENT '创建人',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_by` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '更新人',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `del_flag` tinyint(1) NOT NULL DEFAULT '0' COMMENT '删除标志，0：未删除；1：已删除',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户表';

insert  into `sys_user`(`id`,`user_name`,`nick_name`,`password`,`two_fa_secret`,`tow_fa_enabled`,`create_by`,`create_time`,`update_by`,`update_time`,`del_flag`) values 
(1,'kdyzm','狂盗一枝梅','123456','H5C7U7M3FJN6DGL6EAAWHF6TVAAINAGU',0,'kdyzm','2025-06-16 13:51:03',NULL,'2025-06-17 13:37:13',0);

CREATE TABLE `sys_user_2fa` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` bigint DEFAULT NULL COMMENT '用户id',
  `secret_key` varchar(64) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '秘钥',
  `scratch_codes` varchar(128) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '静态验证码',
  `create_by` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '创建人',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_by` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '更新人',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `del_flag` tinyint(1) NOT NULL DEFAULT '0' COMMENT '删除标志，0：未删除；1：已删除',
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_user_id` (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='两步验证相关临时配置表';

之后修改配置文件中的Mysql配置信息：

JDBC_MYSQL_HOST: localhost
JDBC_MYSQL_PORT: 3306
JDBC_MYSQL_DATABASE: 2fa_demo
JDBC_MYSQL_USERNAME: root
JDBC_MYSQL_PASSWORD: '123456'

项目启动

将项目导入Intelij，运行Application，出现如下即可表示运行成功

打开链接，进入登录页面

账号密码登录

在未登录的情况下打开链接http://localhost:8024，就会进入登录页面

登录账号：kdyzm

登录密码：123456

登录成功之后进入首页。

开启两步验证

登录成功之后进入首页，点击首页右上角两步验证

进入两步验证页面，由于未设置过二次验证，所以会提示去设置

点击“开启二次验证”按钮，进入两步骤验证向导

点击下一步输入电子邮件

点击下一步，进入关键的验证器配置步骤

在这一步，IOS下可以安装Authenticator或者微信小程序搜索“MFA”，使用“腾讯身份验证器”扫描二维码完成验证器设置，注意，如果多次扫描相同的二维码，需要删除上次扫描的记录。

点击下一步，校验配置的正确性：

提示配置开启成功即表示已配置成功。

验证两步验证

退出登录，回到登录页，输入账号密码登录，登录成功后不再跳转到首页，而是跳转到二次验证页面：

从手机上获取动态验证码，即可成功登录系统。

关闭两步验证

进入首页后，再次进入两步验证页面，即可看到关闭按钮

关闭后再次登录系统，就不会进入两步验证页面了。

4、实战总结

由于本项目案例只关注2FA相关的内容，我在光年Admin模板的静态模板只实现了登录以及2FA相关的功能，而且时间匆忙代码比较糙。。。

该项目还剩下一些问题没实现

二次验证的记住设备功能
8位数的静态码未实现校验功能
设备丢失静态码找回功能未实现

以后有时间再补充了。

END.

Python正则表达式指南

Thu, 12 Jun 2025 14:59:06 +0800

正则表达式在各种语言中都是一个复杂的主题，在Python中，正则表达式设计的尤其复杂以适应不同场景下的脚本。

python官方文档提供了正则表达式使用中的各种细节：

《正则表达式指南》

《re --- 正则表达式操作》

如果仔仔细细看完这些文档，正则表达式也就掌握的差不多了，然鹅文档太长了，而且格式排版让人相当的难受，我将其常用功能重新分类整理，以方便查询。

一、元字符和转义字符

关于元字符和转义字符，可以参考官方文档：《正则表达式语法》或者我整理的手册：《Python正则表达式匹配字符手册》，这里重新复习下核心内容部分。

大多数字母和符号都会简单地匹配自身。例如，正则表达式 test 将会精确地匹配到 test 。（你可以启用不区分大小写模式，让这个正则也匹配 Test 或 TEST ，稍后会详细介绍。）

但该规则有例外。有些字符是特殊的 元字符（metacharacters），并不匹配自身。事实上，它们表示匹配一些非常规的内容，或者通过重复它们或改变它们的含义来影响正则的其他部分。本文的大部分内容都致力于讨论各种元字符及其作用。

这是元字符的完整列表：

. ^ $ * + ? { } [ ] \ | ( )

首先介绍的元字符是 [ 和 ] 。这两个元字符用于指定一个字符类，也就是你希望匹配的字符的一个集合。这些字符可以单独地列出，也可以用字符范围来表示（给出两个字符并用 '-' 分隔）。例如，[abc] 将匹配 a、b、c 之中的任意一个字符；这与 [a-c] 相同，后者使用一个范围来表达相同的字符集合。如果只想匹配小写字母，则正则表达式将是 [a-z] 。

元字符 (除了 \) 在字符类中是不起作用的。例如，[akm$] 将会匹配以下任一字符 'a', 'k', 'm' 或 '$'；'$' 通常是一个元字符，但在一个字符类中它的特殊性被消除了。

你可以通过对集合取反来匹配字符类中未列出的字符。方法是把 '^' 放在字符类的最开头。例如，[^5] 将匹配除 '5' 之外的任何字符。如果插入符出现在字符类的其他位置，则它没有特殊含义。例如：[5^] 将匹配 '5' 或 '^'。

也许最重要的元字符是反斜杠，\ 。与 Python 字符串字面量一样，反斜杠后面可以跟各种字符来表示各种特殊序列。它还用于转义元字符，以便可以在表达式中匹配元字符本身。例如，如果需要匹配一个 [ 或 \ ，可以在其前面加上一个反斜杠来消除它们的特殊含义：\[ 或 \\ 。

一些以 '\' 开头的特殊序列表示预定义的字符集合，这些字符集通常很有用，例如数字集合、字母集合或非空白字符集合。

让我们举一个例子：\w 匹配任何字母数字字符，\w 相当于字符类 [a-zA-Z0-9_] 。

以下为特殊序列的不完全列表。完整列表参见标准库参考中正则表达式语法部分。

转义字符	作用
`\d`	匹配任何十进制数字，等价于字符类 `[0-9]` 。
`\D`	匹配任何非数字字符，等价于字符类 `[^0-9]` 。
`\s`	匹配任何空白字符，等价于字符类 `[ \t\n\r\f\v]` 。
`\S`	匹配任何非空白字符，等价于字符类 `[^ \t\n\r\f\v]` 。
`\w`	匹配任何字母与数字字符，等价于字符类 `[a-zA-Z0-9_]` 。
`\W`	匹配任何非字母与数字字符，等价于字符类 `[^a-zA-Z0-9_]` 。

这些序列可以包含在字符类中。例如，[\s,.] 是一个匹配任何空白字符、',' 或 '.' 的字符类。

二、简单正则

让我们从最简单的正则表达式开始吧。由于正则表达式是用来操作字符串的，我们将从最常见的任务开始：匹配字符。能够匹配各种各样的字符集合是正则表达式可以做到的第一件事。

我们先来说说重复元字符 * 。 * 并不是匹配一个字面字符 '*' 。实际上，它指定前一个字符可以匹配零次或更多次，而不是只匹配一次。

例如，ca*t 将匹配 'ct' （ 0 个 'a' ）、'cat' （ 1 个 'a' ）、 'caaat' （ 3 个 'a' ）等等。

1、贪婪匹配

类似 * 这样的重复是 贪婪的 。当重复正则时，匹配引擎将尝试重复尽可能多的次数。如果表达式的后续部分不匹配，则匹配引擎将回退并以较少的重复次数再次尝试。

通过一个逐步示例更容易理解这一点。让我们分析一下表达式 a[bcd]*b 。该表达式首先匹配一个字母 'a' ，接着匹配字符类 [bcd] 中的零个或更多个字母，最后以一个 'b' 结尾。现在想象一下用这个正则来匹配字符串 'abcbd' 。

步骤	匹配	说明
1	`a`	正则中的 `a` 匹配成功。
2	`abcbd`	引擎尽可能多地匹配 `[bcd]*` ，直至字符串末尾。
3	失败	引擎尝试匹配 `b` ，但是当前位置位于字符串末尾，所以匹配失败。
4	`abcb`	回退，让 `[bcd]*` 少匹配一个字符。
5	失败	再次尝试匹配 `b` ，但是当前位置上的字符是最后一个字符 `'d'` 。
6	`abc`	再次回退，让 `[bcd]*` 只匹配 `bc` 。
7	`abcb`	再次尝试匹配 `b` 。这一次当前位置的字符是 `'b'` ，所以它成功了。

此时正则表达式已经到达了尽头，并且匹配到了 'abcb' 。这个例子演示了匹配引擎一开始会尽其所能地进行匹配，如果没有找到匹配，它将逐步回退并重试正则的剩余部分，如此往复，直至 [bcd]* 只匹配零次。如果随后的匹配还是失败了，那么引擎会宣告整个正则表达式与字符串匹配失败。

贪婪匹配在实际业务中会存在比较严重的问题，特别是在HTML解析方面，贪婪匹配的特性会让人很困惑。

看以下案例：

我们实际上想匹配第一个<html>标签，但是由于贪婪匹配的特性，最终匹配到了整个字符串。如何解决这个问题呢？

解决方案是使用 非贪婪限定符 ?，在代表重复的元字符后加上?即可限制正则表达式的贪婪匹配特性： *?, +?, ?? 或 {m,n}?，它们会匹配尽可能少的文本。

在一开始的a[bcd]*b 正则匹配中，只需要将正则表达式改成a[bcd]*?b即可消除贪婪匹配特性，最终匹配'abcbd'字符串的结果将是ab。

2、代表重复的元字符

上面*是介绍的第一个代表重复的元字符，另一个重复元字符是 + ，表示匹配一次或更多次。请注意 * 与 + 之间的差别。 * 表示匹配零次或更多次，也就是说它所重复的内容是可以完全不出现的。而 + 则要求至少出现一次。举一个类似的例子， ca+t 可以匹配 'cat' （ 1 个 'a' ）或 'caaat' （ 3 个 'a'），但不能匹配 'ct' 。

此外还有两个重复操作符或限定符。问号 ? 表示匹配一次或零次；你可以认为它把某项内容变成了可选的。例如，home-?brew 可以匹配 'homebrew' 或 'home-brew'。

最复杂的限定符是 {m,n}，其中 m 和 n 都是十进制整数。该限定符表示必须至少重复 m 次，至多重复 n 次。例如，a/{1,3}b 将匹配 'a/b', 'a//b' 和 'a///b'。它不能匹配 'ab'，因为其中没有斜杠，也不能匹配 'a////b'，因为其中有四个斜杠。

m 和 n 不是必填的，缺失的情况下会设定为默认值。缺失 m 会解释为最少重复 0 次，缺失 n 则解释为最多重复无限次。

最简单情况 {m} 将与前一项完全匹配 m 次。例如，a/{2}b 将只匹配 'a//b'。

实际上*、+以及?都可以用{m,n}限定符表示： {0,} 等同于 *, {1,} 等同于 +, 而 {0,1} 等同于 ?。在可能的情况下使用 *, + 或 ? 会更好，因为它们更为简短易读。

三、使用正则表达式

现在我们已经了解了一些简单的正则表达式，那么我们如何在 Python 中实际使用它们呢？ re 模块提供了正则表达式引擎的接口，可以让你将正则编译为对象，然后用它们来进行匹配。

1、编译正则表达式

正则表达式被编译成模式对象，模式对象具有各种操作的方法，例如搜索模式匹配或执行字符串替换。

re.compile() 也接受一个可选的 flags 参数，用于启用各种特殊功能和语法变体。我们稍后将介绍可用的设置，但现在只需一个例子

正则作为字符串传递给 re.compile() 。正则被处理为字符串，因为正则表达式不是核心Python语言的一部分，并且没有创建用于表达它们的特殊语法。（有些应用程序根本不需要正则，因此不需要通过包含它们来扩展语言规范。）相反，re 模块只是Python附带的C扩展模块，就类似于 socket 或 zlib 模块。

将正则放在字符串中可以使 Python 语言更简单，但有一个缺点是下一节的主题。

2、原始字符串解决反斜杠灾难

我们来思考一个问题，如何写一个正则表达式以匹配字符串\section？

我们知道正则表达式使用反斜杠字符 ('\') 来表示特殊形式，比如\d表示数字，\D表示非数字等；普通字符串中反斜杠也是转义符号，比如\n是换行符，\t是制表符，使用\"来避免字符串提前结束等。

在本案例中，正则表达式中的反斜杠必须是原始反斜杠符号，所以正则表达式可以先写成\\s.*以抵消正则表达式中的反斜杠转义，然而这还不行，因为正则表达式本身要作为字符串使用，反斜杠在Python字符串中也有转义作用，所以必须要对\\s.*做再次转义：\\\\s.*；回到\section字符串，他作为被匹配的字符串，里面的转义符号也应当取消，所以它在Python字符串中的正确写法是\\section，完整的程序如下所示：

>>> import re
>>> p = re.compile('\\\\s.*')
>>> p.match('\\section')
<re.Match object; span=(0, 8), match='\\section'>

可以看到，反斜杠在正则表达式中使用的时候要非常谨慎，当作为原始字符反斜杠使用的时候正则表达式更为复杂且难读懂，如何解决这个问题呢？

答案是：使用**原始字符串**，Python中的原始字符串以前缀'r'开头，原始字符串不处理反斜杠的转义功能，这意味着r"\n" 是一个包含 '\' 和 'n' 的双字符字符串，而 "\n" 是一个包含换行符的单字符字符串。正则表达式通常使用这种原始字符串表示法表示。

回到本节的主题，使用原始字符串写法如何写一个正则表达式以匹配字符串\section？

>>> import re
>>> p = re.compile(r'\\s.*')
>>> p.match(r'\section')
<re.Match object; span=(0, 8), match='\\section'>

3、匹配和查询

一旦你有一个表示编译正则表达式的对象，你用它做什么？模式对象有几种方法和属性。这里只介绍最重要的内容；请参阅 re 文档获取完整列表。

方法 / 属性	目的
`match()`	确定正则是否从字符串的开头匹配
`search()`	扫描字符串，查找此正则匹配的任何位置
`findall()`	找到正则匹配的所有子字符串，并将它们作为列表返回。
`finditer()`	找到正则匹配的所有子字符串，并将它们返回为一个 iterator。

如果没有找到匹配， match() 和 search() 返回 None 。如果它们成功，一个匹配对象实例将被返回，包含匹配相关的信息：起始和终结位置、匹配的子串以及其它。

>>> import re
>>> p = re.compile(r'\d+')
>>> m = p.match('')
>>> print(m)
None
>>> m = p.match('123a')
>>> print(m)
<re.Match object; span=(0, 3), match='123'>

匹配对象中有以下几个方法最为重要：

方法 / 属性	目的
`group()`	返回正则匹配的字符串
`start()`	返回匹配的开始位置
`end()`	返回匹配的结束位置
`span()`	返回包含匹配 (start, end) 位置的元组

>>> m.group()
'123'
>>> m.start(),m.end()
(0, 3)
>>> m.span()
(0, 3)

group() 返回正则匹配的子字符串。 start() 和 end() 返回匹配的起始和结束索引。 span() 在单个元组中返回开始和结束索引。 由于 match() 方法只检查正则是否在字符串的开头匹配，所以 start() 将始终为零。 但是，模式的 search() 方法会扫描字符串，因此在这种情况下匹配可能不会从零开始。

>>> m = p.match('a123')
>>> print(m)
None
>>> m = p.search('a123')
>>> print(m)
<re.Match object; span=(1, 4), match='123'>

在实际程序中，最常见的样式是在变量中存储匹配对象，然后检查它是否为 None。这通常看起来像:

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

match方法和search方法返回Match对象；findall返回匹配字符串的列表，即所有匹配项：

>>> import re
>>> p = re.compile(r'\d+')
>>> p.findall('11 people eat 24 apples ,every people eat 2 apples.')
['11', '24', '2']

findall() 必须先创建整个列表才能返回结果。 finditer() 方法将一个匹配对象的序列返回为一个 iterator

>>> import re
>>> p = re.compile(r'\d+')
>>> iter = p.finditer('11 people eat 24 apples ,every people eat 2 apples.')
>>> for item in iter:
...     print(item)
...
<re.Match object; span=(0, 2), match='11'>
<re.Match object; span=(14, 16), match='24'>
<re.Match object; span=(42, 43), match='2'>
>>>

4、分割字符串

模式的 split() 方法在正则匹配的任何地方拆分字符串，返回一个片段列表。它类似于 split() 字符串方法，但在分隔符的分隔符中提供了更多的通用性；字符串的 split() 仅支持按空格或固定字符串进行拆分。

.split(string[, maxsplit=0])

如果 maxsplit 非零，则最多执行 maxsplit 次拆分，并且字符串的其余部分将作为列表的最后一个元素返回。在以下示例中，分隔符是任何非字母数字字符序列。

>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
>>> p.split('This is a test, short and sweet, of split().', 3)
['This', 'is', 'a', 'test, short and sweet, of split().']

如果在正则中使用捕获括号，则它们的值也将作为列表的一部分返回。比较以下调用:

>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
['This', 'is', 'a', 'test', '']
>>> p2.split('This... is a test.')
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']

5、替换字符串

另一个常见任务是找到模式的所有匹配项，并用不同的字符串替换它们。 sub() 方法接受一个替换值，可以是字符串或函数，也可以是要处理的字符串。

.sub(replacement, string[, count=0])

返回通过替换 replacement 替换 string 中正则的最左边非重叠出现而获得的字符串。如果未找到模式，则 string 将保持不变。

可选参数 count 是要替换的模式最大的出现次数；count 必须是非负整数。默认值 0 表示替换所有。

这是一个使用 sub() 方法的简单示例。它用 colour 这个词取代颜色名称:

subn() 方法完成相同的工作，但返回一个包含新字符串值和已执行的替换次数的 2 元组:

空匹配陷阱

要注意当正则表达式能匹配空字符串的时候会在每个字符之间以及字符串首尾都添加替换的字符串

空匹配在分割字符串的场景下也会发生：

>>> p = re.compile('x*')
>>> p.split('apple')
['', 'a', 'p', 'p', 'l', 'e', '']
>>>

后向引用

如果 replacement 是一个字符串，则处理其中的任何反斜杠转义。也就是说，\n 被转换为单个换行符，\r 被转换为回车符，依此类推。诸如 \& 之类的未知转义是孤立的。 后向引用，例如 \6，被替换为正则中相应组匹配的子字符串。这使你可以在生成的替换字符串中合并原始文本的部分内容。

这个例子匹配单词 section 后跟一个用 {，} 括起来的字符串，并将 section 改为 subsection

>>> p = re.compile('section{([^}]*)}')
>>> p.sub(r'subsection{\1}','section{First} section{second}')
'subsection{First} subsection{second}'
>>>

还有一种语法用于引用由 (?P<name>...) 语法定义的命名组。\g\<name> 将使用名为 name 的组匹配的子字符串，\g\<number> 使用相应的组号。因此 \g<2> 等同于 \2。

>>> p=re.compile('section{(?P<name>[^}]*)}')
>>> p.sub(r'subsection{\1}','section{First} section{second}')
'subsection{First} subsection{second}'
>>> p.sub(r'subsection{\g<1>}','section{First} section{second}')
'subsection{First} subsection{second}'
>>> p.sub(r'subsection{\g<name>}','section{First} section{second}')
'subsection{First} subsection{second}'

替换函数

replacement还可以是一个函数，它可以为你提供更多控制。如果 replacement 是一个函数，则为 pattern 的每次非重叠出现将调用该函数。在每次调用时，函数都会传递一个匹配的匹配对象参数，并可以使用此信息计算所需的替换字符串并将其返回。

>>> import re
>>>
>>> p = re.compile(r"(\d+)")
>>>
>>>
>>> def replacment_fun(match: re.Match):
...     match_str = match.group()
...     return match_str + "_"
...
>>> result = p.sub(replacment_fun, "11 people eat 22 apples , every people eat 2 apples.")
>>> print(result)
11_ people eat 22_ apples , every people eat 2_ apples.
>>>

6、模块级函数

模块级函数让我们不必创建模式对象并调用其方法：re 模块提供了顶级函数 match()，search()，findall()，sub() 等等。这些函数采用与相应模式方法相同的参数，并将正则字符串作为第一个参数添加，并仍然返回 None 或匹配对象实例。:

>>> print(re.match(r'From\s+', 'Fromage amk'))
None
>>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')
<re.Match object; span=(0, 5), match='From '>

本质上，这些函数只是为你创建一个模式对象，并在其上调用适当的方法。它们还将编译对象存储在缓存中，因此使用相同的未来调用将不需要一次又一次地解析该模式。

你是否应该使用这些模块级函数，还是应该自己获取模式并调用其方法？如果你正在循环中访问正则表达式，预编译它将节省一些函数调用。在循环之外，由于有内部缓存，没有太大区别。

7、编译标志

编译标志允许你修改正则表达式的工作方式。标志在 re 模块中有两个名称，长名称如 IGNORECASE 和一个简短的单字母形式，例如 I。（如果你熟悉 Perl 的模式修饰符，则单字母形式使用和其相同的字母；例如， re.VERBOSE 的缩写形式为 re.X。）多个标志可以通过按位或运算来指定它们；例如，re.I | re.M 设置 I 和 M 标志。

标志	含意
`ASCII`, `A`	使几个转义如 `\w`、`\b`、`\s` 和 `\d` 匹配仅与具有相应特征属性的 ASCII 字符匹配。
`DOTALL`, `S`	使 `.` 匹配任何字符，包括换行符。
`IGNORECASE`, `I`	进行大小写不敏感匹配。
`LOCALE`, `L`	进行区域设置感知匹配。
`MULTILINE`, `M`	多行匹配，影响 `^` 和 `$`。
`VERBOSE`, `X` （为 '扩展'）	启用详细的正则，可以更清晰，更容易理解。

在上述表格中的标记中，需要特别关心的标记实际上有四个：DOTALL、IGNORECASE、MULTILINE、VERBOSE，其余几个可以暂不考虑。

re.DOTALL

该标志使 '.' 匹配任何字符，包括换行符；没有这个标志，'.' 将匹配除了换行符外的任何字符。

举个例子，现在我们有这样一段网页文本：

html_content = """<div>
    <p>This is a paragraph</p>
    <p>Another paragraph</p>
</div>"""

如何使用正则表达式将div标签中的内容提取出来？

尝试写个脚本：

import re

html_content = """<div>
    <p>This is a paragraph</p>
    <p>Another paragraph</p>
</div>"""

# 匹配div标签及其所有内容（包括换行）
div_pattern = r"<div>(.*?)</div>"
match_div = re.search(div_pattern, html_content)
print(match_div)

结果输出是None，也即是说没匹配到。这是因为.*没有匹配到换行符\n，此时就可以用到DOTALL标志了：

>>> import re
>>>
>>> html_content = """<div>
...     <p>This is a paragraph</p>
...     <p>Another paragraph</p>
... </div>"""
>>>
>>> # 匹配div标签及其所有内容（包括换行）
>>> div_pattern = r"<div>(.*?)</div>"
>>> match_div = re.search(div_pattern, html_content, re.DOTALL)
>>> if match_div:
...     print("\nMatched HTML content:", match_div.group(1))
...

Matched HTML content:
    <p>This is a paragraph</p>
    <p>Another paragraph</p>

>>>

re.MULTILINE

通常 ^ 只匹配字符串的开头，而 $ 只匹配字符串的结尾，紧接在字符串末尾的换行符（如果有的话）之前。当指定了这个标志时，^ 匹配字符串的开头和字符串中每一行的开头，紧跟在每个换行符之后。类似地，$ 元字符匹配字符串的结尾和每行的结尾（紧接在每个换行符之前）。

听起来有些抽象，举个例子，现在有个提取错误日志的需求，日志格式如下所示：

log_data = """
[INFO] 2023-01-01 10:00:00 Another log entry
[INFO] 2023-01-01 10:00:00 System started
[ERROR] 2023-01-01 10:05:23 Connection failed
[WARNING] 2023-01-01 10:06:10 Low disk space
[ERROR] 2023-01-01 10:00:00 Error details: Connection timeout
[INFO] 2023-01-01 10:10:00 Backup completed
[ERROR] 2023-01-01 10:05:23 Connection failed1
"""

如何将ERROR级别的日志提取出来？先看第一种写法：

p = re.compile(r"^\[ERROR\].*")
result = p.findall(log_data)
for item in result:
    print(item)

这种写法没有匹配到任何日志，原因就在于log_data是作为整体的字符串来查找的，而限定符^要求必须以[ERROR]开头，我们这段字符串是以\n[INFO]开头的，所以并不会被匹配到，解决方式就是使用re.MULTILINE标志。

使用re.MULTILINE之后，每行字符串都能在开头被^匹配，结尾被$匹配。

好了，现在我们来看看进阶问题，现在日志格式变成了如下所示：

log_data = """
[INFO] 2023-01-01 10:00:00 Another log entry
[INFO] 2023-01-01 10:00:00 System started
[ERROR] 2023-01-01 10:05:23 Connection failed
[WARNING] 2023-01-01 10:06:10 Low disk space
[ERROR] 2023-01-01 10:00:00
    Error details: Connection timeout
    Stack trace:
        at com.example.App.main(App.java:10)
[INFO] 2023-01-01 10:10:00 Backup completed
[ERROR] 2023-01-01 10:05:23 Connection failed1
"""

没错，错误日志有换行了，如何将错误日志完整的提取出来？使用之前的正则表达式r"^\[ERROR\].*"会遗漏部分日志。需要考虑以下几点：

错误日志必须从每行[ERROR]开始匹配，所以需要用到re.MULTILINE标志；但是匹配的时候要跨行匹配，所以需要用到re.DOTALL，两者都要使用，则要使用re.MULTILINE | re.DOTALL
由于正则表达式的默认贪婪匹配规则，会一次性匹配出最长的字符串，所以要禁用贪婪匹配，方法就是在重复标记后加上问号?，在这里要使用.*?
.*要有截止条件，这里要使用前视断言，前视断言是一种零宽度断言（关于前视断言在后续章节介绍），这里要同时考虑到ERROR日志在最后一行的情况，所以前视断言的写法为：(?=\[|\Z)

综合考虑以上情况，新的正则表达式写法为：p = re.compile(r"^\[ERROR\].*?(?=\[|\Z)", re.MULTILINE | re.DOTALL)

完整代码如下所示：

import re

log_data = """
[INFO] 2023-01-01 10:00:00 Another log entry
[INFO] 2023-01-01 10:00:00 System started
[ERROR] 2023-01-01 10:05:23 Connection failed
[WARNING] 2023-01-01 10:06:10 Low disk space
[ERROR] 2023-01-01 10:00:00
    Error details: Connection timeout
    Stack trace:
        at com.example.App.main(App.java:10)
[INFO] 2023-01-01 10:10:00 Backup completed
[ERROR] 2023-01-01 10:05:23 Connection failed1
"""

p = re.compile(r"^\[ERROR\].*?(?=\[|\Z)", re.MULTILINE | re.DOTALL)
result = p.findall(log_data)
for item in result:
    print(item)

re.VERBOSE

此标志允许你编写更易读的正则表达式，方法是为您提供更灵活的格式化方式。指定此标志后，将忽略正则字符串中的空格，除非空格位于字符类中或前面带有未转义的反斜杠；这使你可以更清楚地组织和缩进正则。此标志还允许你将注释放在正则中，引擎将忽略该注释；注释标记为 '#' 既不是在字符类中，也不是在未转义的反斜杠之前。

例如，这里的正则使用 re.VERBOSE

charref = re.compile(r"""
 &[#]                # 数字实体引用的开始
 (
     0[0-7]+         # 八进制形式
   | [0-9]+          # 十进制形式
   | x[0-9a-fA-F]+   # 十六进制形式
 )
 ;                   # 末尾分号
""", re.VERBOSE)

如果没有详细设置，正则将如下所示:

charref = re.compile("&#(0[0-7]+"
                     "|[0-9]+"
                     "|x[0-9a-fA-F]+);")

四、正则表达式进阶

上面章节介绍了正则表达式的基本使用，下面介绍正则表达式的进阶写法。

1、零宽度断言

上面已经讨论过.、*、?以及\d等转义字符，它们都有一个特点：它们本身代表着匹配字符串中的某一段文本。有这样一种字符，它们在匹配字符串中不占用任何字符，只是代表成功或者失败，这种特殊的匹配字符叫做零宽度断言。例如，\b 是一个断言，指明当前位置位于字边界；这个位置根本不会被 \b 改变。这意味着永远不应重复零宽度断言，因为如果它们在给定位置匹配一次，它们显然可以无限次匹配。

零宽度断言包含常见的\^$\A\Z\B\b以及前视断言。

元字符和转义字符中的零宽度断言

|

^

在行的开头匹配。除非设置了 MULTILINE 标志，否则只会在字符串的开头匹配。在 MULTILINE 模式下，这也在字符串中的每个换行符后立即匹配。

例如，如果你希望仅在行的开头匹配单词 From，则要使用的正则 ^From。:

>>> print(re.search('^From', 'From Here to Eternity'))
<re.Match object; span=(0, 4), match='From'>
>>> print(re.search('^From', 'Reciting From Memory'))
None

要匹配字面 '^'，使用 \^。

$

匹配行的末尾，定义为字符串的结尾，或者后跟换行符的任何位置。:

>>> print(re.search('}$', '{block}'))
<re.Match object; span=(6, 7), match='}'>
>>> print(re.search('}$', '{block} '))
None
>>> print(re.search('}$', '{block}\n'))
<re.Match object; span=(6, 7), match='}'>

以匹配字面 '$'，使用 \$ 或者将其包裹在一个字符类中，例如 [$]。

\A

仅匹配字符串的开头。当不在 MULTILINE 模式时，\A 和 ^ 实际上是相同的。在 MULTILINE 模式中，它们是不同的: \A 仍然只在字符串的开头匹配，但 ^ 可以匹配在换行符之后的字符串内的任何位置。

\Z

只匹配字符串尾。

\b

字边界。这是一个零宽度断言，仅在单词的开头或结尾处匹配。单词被定义为一个字母数字字符序列，因此单词的结尾由空格或非字母数字字符表示。

以下示例仅当它是一个完整的单词时匹配 class；当它包含在另一个单词中时将不会匹配。

>>> p = re.compile(r'\bclass\b')
>>> print(p.search('no class at all'))
<re.Match object; span=(3, 8), match='class'>
>>> print(p.search('the declassified algorithm'))
None
>>> print(p.search('one subclass is'))
None

使用这个特殊序列时，你应该记住两个细微之处。首先，这是 Python 的字符串文字和正则表达式序列之间最严重的冲突。在 Python 的字符串文字中，\b 是退格字符，ASCII 值为8。如果你没有使用原始字符串，那么 Python 会将 \b 转换为退格，你的正则不会按照你的预期匹配。以下示例与我们之前的正则看起来相同，但省略了正则字符串前面的 'r'。:

>>> p = re.compile('\bclass\b')
>>> print(p.search('no class at all'))
None
>>> print(p.search('\b' + 'class' + '\b'))
<re.Match object; span=(0, 7), match='\x08class\x08'>

其次，在一个字符类中，这个断言没有用处，\b 表示退格字符，以便与 Python 的字符串文字兼容。

\B

另一个零宽度断言，这与 \b 相反，仅在当前位置不在字边界时才匹配。

前视断言和后视断言

从“断言”这个词上看，就知道该功能的作用是“判断”，它只有两个值：True或者False。那判断什么呢？

(?=…)

肯定型前视断言。如果内部的表达式（这里用 ... 来表示）在当前位置可以匹配，则匹配成功，否则匹配失败。但是，内部表达式尝试匹配之后，正则引擎并不会向前推进；正则表达式的其余部分依然会在断言开始的地方尝试匹配。

举个例子，在之前re.MULTILINE章节介绍的正则表达式^\[ERROR\].*?(?=\[|\Z)，用于提取ERROR级别的完整日志，其中(?=\[|\Z)就是前视断言，它前面的.*不能无限匹配到字符串最后，需要有个停止条件，停止条件就是匹配到字符[（[字符表示下一条日志的开头）或者匹配到字符串最后也就是\Z（\Z能匹配到表示当前匹配的ERROR级别的日志在最后一条）；如果没匹配到，则将会匹配失败。

(?!…)

否定型前视断言。与肯定型断言正好相反，如果内部表达式在字符串中的当前位置不匹配，则成功。

(?<=...)

肯定型后视断言，它也是一种零宽度断言，表示匹配的内容必须出现在指定模式（断言）之后。

举个例子，我们有一段文本，text = "Price: $100, Discount: $50, i have 11 mantou"，我们想提取出来以$开头的数字，如何实现？可以使用re.findall(r'\$\d+',text) 提取出来包含$符号的：

但是这样并不符合我们的要求，我们要以$符号开头，但是只要数字。这时候就可以使用肯定型后视断言了，正则表达式可以这样写：re.findall(r'(?<=\$)\d+', text)，这表示必须以$符号开头，但是不要匹配$，只要数字。

(?<!...)

否定型后视断言，表示匹配的内容不能出现在指定的模式之后

总而言之，前视断言和后视断言在需要匹配特定上下文但不希望这些上下文成为匹配结果一部分时非常有用。

2、捕获组（分组）

分组是用 '(', ')' 元字符来标记的。 '(' 和 ')' 与它们在数学表达式中的含义基本一致：它们会将所包含的表达式合为一组，并且你可以使用限定符例如 *, +, ?, 或 {m,n} 来重复一个分组的内容。举例来说，(ab)* 将匹配 ab 的零次或多次重复。

>>> p = re.compile('(ab)*')
>>> print(p.match('ababababab').span())
(0, 10)

用 '('，')' 表示的组也捕获它们匹配的文本的起始和结束索引；这可以通过将参数传递给 group()、start()、end() 以及 span()。组从 0 开始编号。组 0 始终存在；它表示整个正则，所以匹配对象方法都将组 0 作为默认参数。稍后我们将看到如何表达不捕获它们匹配的文本范围的组。

>>> p = re.compile('(a)b')
>>> m = p.match('ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'

子组从左到右编号，从 1 向上编号。组可以嵌套；要确定编号，只需计算从左到右的左括号字符。

>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

group() 可以一次传递多个组号，在这种情况下，它将返回一个包含这些组的相应值的元组。:

>>> m.group(2,1,2)
('b', 'abc', 'b')

groups() 方法返回一个元组，其中包含所有子组的字符串，从1到最后一个子组。:

>>> m.groups()
('abc', 'b')

模式中的后向引用允许你指定还必须在字符串中的当前位置找到先前捕获组的内容。例如，如果可以在当前位置找到组 1 的确切内容，则 \1 将成功，否则将失败。请记住，Python 的字符串文字也使用反斜杠后跟数字以允许在字符串中包含任意字符，因此正则中引入反向引用时务必使用原始字符串。

例如，以下正则检测字符串中重复的单词。:

>>> p = re.compile(r'\b(\w+)\s+\1\b')
>>> p.search('Paris in the the spring').group()
'the the'

分组重复

分组如果储存在重复，则在捕获的时候，下一次的捕获会覆盖上一次的捕获。如何理解这句话？还是之前的例子：

>>> p = re.compile('(ab)*')
>>> print(p.match('ababababab').span())
(0, 10)

(ab)*可以完全匹配ababababab，group()和group(0)都是ababababab，但是group(1)以及groups()都是ab，实际上(ab)分组匹配了5次，ab则是最后一个分组捕获的结果。

如果上述案例难以理解，可以再看下面的案例：正则表达式([abc])+匹配'abc'字符串。

分别匹配了(a)+、(b)+、(c)+并捕获成功，(b)+覆盖了(a)+的捕获结果，(c)+覆盖了(b)+的捕获结果，所以最后的捕获结果只剩下了(c)+的捕获结果'c'。

分组重复和一般分组不一样，无论重复多少次，最终保留下来的只有最后一次捕获结果。

3、非捕获组

有时我们会想要使用组来表示正则表达式的一部分，但是对检索组的内容不感兴趣。你可以通过使用非捕获组来显式表达这个事实: (?:...)，你可以用任何其他正则表达式替换 ...。注意非捕获组的格式是(?:...)和前视断言(?=...)不同。

来看看使用正则表达式r'(\d+)asdf'匹配'1234asdf'，

可以看到捕获组捕获到了1234作为group(1)。如果我将正则表达式改成r'(?:\d+)asdf' 会怎样？

可以看到，非捕获组的作用就是能匹配，但是不捕获。

4、命名分组

前面说的非捕获组(?:...)以及前视断言(?=...)实际上都是Python 支持的 Perl 的扩展，命名组的格式是(?P=<name>...)，它是Python的特定扩展之一，name 显然是该组的名称。使用命名组的时候，可以同时使用数字编号以及组名字符串来关联对应的捕获组。

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'
>>> m.group(1)
'Lots'

注意search方法只找第一个匹配，所以只输出了Lots，如果想获取所有匹配，应当使用findall或者finditer方法。

命名分组提取为字典

我们可以通过 groupdict() 将命名分组提取为一个字典:

>>> m = re.match(r'(?P<first>\w+)\s+(?P<last>\w+)', 'Jane Doe')
>>> m.groupdict()
{'first': 'Jane', 'last': 'Doe'}

后向引用

后向引用是一种新的扩展语法，它的使用格式是：(?P=name)。

举个例子，用于查找重复单词的正则表达式\b(\w+)\s+\1\b 也可以写为 \b(?P<word>\w+)\s+(?P=word)\b

>>> p = re.compile(r'\b(?P<word>\w+)\s+(?P=word)\b')
>>> p.search('Paris in the the spring').group()
'the the'

要注意，在sub替换字符串方法中，命名分组的后向引用要使用\g\<name>的形式，相关功能科参考替换字符串章节。

END.

Python正则表达式匹配字符手册

Tue, 10 Jun 2025 22:32:25 +0800

本篇文章是python正则匹配字符手册，用于方便查阅元字符和转义字符相关的细节，不涉及正则表达式如何书写问题。这部分内容更像是一个手册，用来以后查询使用，想要全部记住有些不容易的。

大多数字母和符号都会简单地匹配自身。例如，正则表达式 test 将会精确地匹配到 test 。但该规则有例外：有些字符是特殊的 元字符（metacharacters），并不匹配自身。

一、元字符

元字符是一种特殊的字符，它并不匹配自身，事实上，它们表示匹配一些非常规的内容，或者通过重复它们或改变它们的含义来影响正则的其他部分。正则表达式的编写几乎就是围绕如何运用元字符来展开的。

这是元字符的完整列表。

. ^ $ * + ? { } [ ] \ | ( )

.

（点号.）在默认模式下，匹配除换行符以外的任意字符。如果指定了旗标 DOTALL，它将匹配包括换行符在内的任意字符。 (?s:.) 将匹配任意字符而无视相关旗标。

^

(插入符) 匹配字符串的开头，并且在 MULTILINE 模式下也匹配换行后的首个符号。

$

匹配字符串尾或者在字符串尾的换行符的前一个字符，在 MULTILINE 模式下也会匹配换行符之前的文本。 foo 匹配 'foo' 和 'foobar'，但正则表达式 foo$ 只匹配 'foo'。更有趣的是，在 'foo1\nfoo2\n' 中搜索 foo.$，通常匹配 'foo2'，但在 MULTILINE 模式下可以匹配到 'foo1'；在 'foo\n' 中搜索 $ 会找到两个（空的）匹配：一个在换行符之前，一个在字符串的末尾。

*

对它前面的正则式匹配0到任意次重复，尽量多的匹配字符串。 ab* 会匹配 'a'，'ab'，或者 'a' 后面跟随任意个 'b'。

+

对它前面的正则式匹配1到任意次重复。 ab+ 会匹配 'a' 后面跟随1个以上到任意个 'b'，它不会匹配 'a'。

?

对它前面的正则式匹配0到1次重复。 ab? 会匹配 'a' 或者 'ab'。

*?, +?, ??

'*', '+' 和 '?' 数量限定符都是 贪婪的；它们会匹配尽可能多的文本。有时这种行为并不被需要；如果 RE <.*> 针对 '<a> b <c>' 进行匹配，它将匹配整个字符串，而不只是 '<a>'。在数量限定符之后添加 ? 将使其以 非贪婪 或最小风格来执行匹配；也就是将匹配数量尽可能少的字符。使用 RE <.*?> 将只匹配 '<a>'。

*+, ++, ?+

类似于 '*', '+' 和 '?' 数量限定符，添加了 '+' 的形式也将匹配尽可能多的次数。但是，不同于真正的贪婪型数量限定符，这些形式在之后的表达式匹配失败时不允许反向追溯。这些形式被称为 占有型 数量限定符。例如，a*a 将匹配 'aaaa' 因为 a* 将匹配所有的 4 个 'a'，但是，当遇到最后一个 'a' 时，表达式将执行反向追溯以便最终 a* 最后变为匹配总计 3 个 'a'，而第四个 'a' 将由最后一个 'a' 来匹配。然而，当使用 a*+a 时如果要匹配 'aaaa'，a*+ 将匹配所有的 4 个 'a'，但是在最后一个 'a' 无法找到更多字符来匹配时，表达式将无法被反向追溯并将因此匹配失败。 x*+, x++ 和 x?+ 分别等价于 (?>x*), (?>x+) 和 (?>x?)。Added in version 3.11.

{m}

对其之前的正则式指定匹配 m 个重复；少于 m 的话就会导致匹配失败。比如， a{6} 将匹配6个 'a' , 但是不能是5个。

{m,n}

对正则式进行 m 到 n 次匹配，在 m 和 n 之间取尽量多。比如，a{3,5} 将匹配 3 到 5个 'a'。忽略 m 意为指定下界为0，忽略 n 指定上界为无限次。比如 a{4,}b 将匹配 'aaaab' 或者1000个 'a' 尾随一个 'b'，但不能匹配 'aaab'。逗号不能省略，否则无法辨别修饰符应该忽略哪个边界。

{m,n}?

将导致结果 RE 匹配之前 RE 的 m 至 n 次重复，尝试匹配尽可能少的重复次数。这是之前数量限定符的非贪婪版本。例如，在 6 个字符的字符串 'aaaaaa' 上，a{3,5} 将匹配 5 个 'a' 字符，而 a{3,5}? 将只匹配 3 个字符。

{m,n}+

将导致结果 RE 匹配之前 RE 的 m 至 n 次重复，尝试匹配尽可能多的重复而不会建立任何反向追溯点。这是上述数量限定符的占有型版本。例如，在 6 个字符的字符串 'aaaaaa' 上，a{3,5}+aa 将尝试匹配 5 个 'a' 字符，然后，要求再有 2 个 'a'，这将需要比可用的更多的字符因而会失败，而 a{3,5}aa 的匹配将使 a{3,5} 先捕获 5 个，然后通过反向追溯再匹配 4 个 'a'，然后用模式中最后的 aa 来匹配最后的 2 个 'a'。 x{m,n}+ 就等同于 (?>x{m,n})。

Added in version 3.11.

\

转义特殊字符（允许你匹配 '*', '?', 或者此类其他），或者表示一个特殊序列；特殊序列之后进行讨论。如果你没有使用原始字符串（ r'raw' ）来表达样式，要牢记Python也使用反斜杠作为转义序列；如果转义序列不被Python的分析器识别，反斜杠和字符才能出现在字符串中。如果Python可以识别这个序列，那么反斜杠就应该重复两次。这将导致理解障碍，所以高度推荐，就算是最简单的表达式，也要使用原始字符串。

[]

用于表示一个字符集合。在一个集合中：

字符可以单独列出，比如 [amk] 匹配 'a'， 'm'，或者 'k'。
可以表示字符范围，通过用 '-' 将两个字符连起来。比如 [a-z] 将匹配任何小写ASCII字符， [0-5][0-9] 将匹配从 00 到 59 的两位数字， [0-9A-Fa-f] 将匹配任何十六进制数位。如果 - 进行了转义（比如 [a\-z]）或者它的位置在首位或者末尾（如 [-a] 或 [a-]），它就只表示普通字符 '-'。
除反斜杠外的特殊字符在集中中会失去其特殊含义。例如，[(+*)] 将匹配字符字面值 '(', '+', '*', 或 ')' 中的任何一个。
反斜杠或者用于转义集合中具有特殊含义的字符如 '-', ']', '^' 及 '\\' 本身或者用于提示代表单个字符的特殊序列如 \xa0 或 \n 或者用于字符类如 \w 或 \S (定义见下文)。请注意 \b 是表示单个 "backspace" 字符，而不是如在集合以外那样表示单词边界，还有数字转义符如 \1 将总是为八进制形式的转义，而不是分组引用。不匹配单个字符的特殊转义符如 \A 和 \Z 是不被允许的。are not allowed.
不在集合范围内的字符可以通过取反来进行匹配。如果集合首字符是 '^' ，所有不在集合内的字符将会被匹配，比如 [^5] 将匹配所有字符，除了 '5'， [^^] 将匹配所有字符，除了 '^'. ^ 如果不在集合首位，就没有特殊含义。
要在集合内匹配一个 ']' 字面值，可以在它前面加上反斜杠，或是将它放到集合的开头。例如，[()[\]{}] 和 []()[{}] 都可以匹配右方括号，以及左方括号，花括号和圆括号。
Unicode Technical Standard #18 里的嵌套集合和集合操作支持可能在未来添加。这将会改变语法，所以为了帮助这个改变，一个 FutureWarning 将会在有多义的情况里被 raise，包含以下几种情况，集合由 '[' 开始，或者包含下列字符序列 '--', '&&', '~~', 和 '||'。为了避免警告，需要将它们用反斜杠转义。

在 3.7 版本发生变更: 如果一个字符串构建的语义在未来会改变的话，一个 FutureWarning 会 raise 。

|

(...)

（组合），匹配括号内的任意正则表达式，并标识出组合的开始和结尾。匹配完成后，组合的内容可以被获取，并可以在之后用 \number 转义序列进行再次匹配，之后进行详细说明。要匹配字符 '(' 或者 ')', 用 $ 或 $, 或者把它们包含在字符集合里: [(], [)].

(?…)

这是个扩展标记法（一个 '?' 跟随 '(' 并无含义）。 '?' 后面的第一个字符决定了这个构建采用什么样的语法。这种扩展通常并不创建新的组合； (?P<name>...) 是唯一的例外。以下是目前支持的扩展。

(?aiLmsux)

一个或多个来自 'a', 'i', 'L', 'm', 's', 'u', 'x' 集合的字母。）分组将与空字符串相匹配；这些字母将为整个正则表达式设置相应的旗标：

re.A (仅限 ASCII 匹配)
re.I (忽略大小写)
re.L (依赖于语言区域)
re.M (多行)
re.S (点号匹配所有字符)
re.U (Unicode 匹配)
re.X (详细)

（该旗标在模块内容中有介绍。）这适用于当你希望将该旗标包括为正则表达式的一部分，而不是向 re.compile() 函数传入 flag 参数的情况。旗标应当在表达式字符串的开头使用。

在 3.11 版本发生变更: 此构造只能在表达式的开头使用。

(?:…)

正则括号的非捕获版本。匹配在括号内的任何正则表达式，但该分组所匹配的子字符串不能在执行匹配后被获取或是之后在模式中被引用。

(?aiLmsux-imsx:…)

（零个或多个来自 'a', 'i', 'L', 'm', 's', 'u', 'x' 集合的字母，后面可以带 '-' 再跟一个或多个来自 'i', 'm', 's', 'x' 集合的字母。）这些字母将为这部分表达式设置或移除相应的旗标：

re.A (仅限 ASCII 匹配)
re.I (忽略大小写)
re.L (依赖于语言区域)
re.M (多行)
re.S (点号匹配所有字符)
re.U (Unicode 匹配)
re.X (详细)

（这些旗标在模块内容中有介绍。）

字母 'a', 'L' 和 'u' 在用作内联旗标时是互斥的，所以它们不能相互组合或者带 '-'。相反，当它们中的某一个出现于内联的分组时，它将覆盖外层分组中匹配的模式。在 Unicode 模式中 (?a:...) 将切换至仅限 ASCII 匹配，而 (?u:...) 将切换至 Unicode 匹配（默认）。在字节串模式中 (?L:...) 将切换为基于语言区域的匹配，而 (?a:...) 将切换为仅限 ASCII 匹配（默认）。这种覆盖将只在内联分组范围内生效，而在分组之外将恢复为原始的匹配模式。

Added in version 3.6.

在 3.7 版本发生变更: 符号 'a', 'L' 和 'u' 同样可以用在一个组合内。

(?>...)

尝试匹配 ... 就像它是一个单独的正则表达式，如果匹配成功，则继续匹配在它之后的剩余表达式。如果之后的表达式匹配失败，则栈只能回溯到 (?>...) 之前的点，因为一旦退出，这个被称为 原子化分组 的表达式将会丢弃其自身所有的栈点位。因此，(?>.*). 将永远不会匹配任何东西因为首先 .* 将匹配所有可能的字符，然后，由于没有任何剩余的字符可供匹配，最后的 . 将匹配失败。由于原子化分组中没有保存任何栈点位，并且在它之前也没有任何栈点位，因此整个表达式将匹配失败。

Added in version 3.11.

(?P<name>…)

与常规的圆括号类似，但分组所匹配到了子字符串可通过符号分组名称 name 来访问。分组名称必须是有效的 Python 标识符，并且在 bytes 模式中它们只能包含 ASCII 范围内的字节值。每个分组名称在一个正则表达式中只能定义一次。一个符号分组同时也是一个编号分组，就像这个分组没有被命名过一样。

命名组合可以在三种上下文中引用。如果样式是 (?P<quote>['"]).*?(?P=quote) （也就是说，匹配单引号或者双引号括起来的字符串)：

引用组合 "quote" 的上下文	引用方法
在正则式自身内	`(?P=quote)` (如示)`\1`
处理匹配对象 m	m.group('quote')``m.end('quote') (等)
传递到 `re.sub()` 里的 repl 参数中	\g<quote>``\g<1>``\1

在 3.12 版本发生变更: 在 bytes 模式中，分组 name 只能包含 ASCII 范围内的字节值 (b'\x00'-b'\x7f')。

(?P=name)

反向引用一个命名组合；它匹配前面那个叫 name 的命名组中匹配到的串同样的字串。

(?#…)

注释；里面的内容会被忽略。

(?=…)

当 … 匹配时，匹配成功，但不消耗字符串中的任何字符。这个叫做 前视断言 （lookahead assertion）。比如， Isaac (?=Asimov) 将会匹配 'Isaac ' ，仅当其后紧跟 'Asimov' 。

(?!…)

当 … 不匹配时，匹配成功。这个叫 否定型前视断言 （negative lookahead assertion）。例如， Isaac (?!Asimov) 将会匹配 'Isaac ' ，仅当它后面不是 'Asimov' 。

(?<=…)

如果 ... 的匹配内容出现在当前位置的左侧，则匹配。这叫做 肯定型后视断言 （positive lookbehind assertion）。 (?<=abc)def 将会在 'abcdef' 中找到一个匹配，因为后视会回退3个字符并检查内部表达式是否匹配。内部表达式（匹配的内容）必须是固定长度的，意思就是 abc 或 a|b 是允许的，但是 a* 和 a{3,4} 不可以。注意，以肯定型后视断言开头的正则表达式，匹配项一般不会位于搜索字符串的开头。很可能你应该使用 search() 函数，而不是 match() 函数：

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

这个例子搜索一个跟随在连字符后的单词：

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

在 3.5 版本发生变更: 添加定长组合引用的支持。

(?<!…)

如果 ... 的匹配内容没有出现在当前位置的左侧，则匹配。这个叫做 否定型后视断言 （negative lookbehind assertion）。类似于肯定型后视断言，内部表达式（匹配的内容）必须是固定长度的。以否定型后视断言开头的正则表达式，匹配项可能位于搜索字符串的开头。

(?(id/name)yes-pattern|no-pattern)

如果给定的 id 或 name 存在，将会尝试匹配 yes-pattern ，否则就尝试匹配 no-pattern，no-pattern 可选，也可以被忽略。比如， (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) 是一个email样式匹配，将匹配 '<user@host.com>' 或 'user@host.com' ，但不会匹配 '<user@host.com' ，也不会匹配 'user@host.com>'。

在 3.12 版本发生变更: 分组 id 只能包含 ASCII 数码。在 bytes 模式中，分组 name 只能包含 ASCII 范围内的字节值 (b'\x00'-b'\x7f')。

由 '\' 和一个字符组成的特殊序列在以下列出。如果普通字符不是ASCII数位或者ASCII字母，那么正则样式将匹配第二个字符。比如，\$ 匹配字符 '$'.

二、转义字符

转义字符是通过转义符号\加上字母或者数字的特殊组合形式用以代表特定字符序列的组合字符。

\number

匹配数字代表的组合。每个括号是一个组合，组合从1开始编号。比如 (.+) \1 匹配 'the the' 或者 '55 55', 但不会匹配 'thethe' (注意组合后面的空格)。这个特殊序列只能用于匹配前面99个组合。如果 number 的第一个数位是0，或者 number 是三个八进制数，它将不会被看作是一个组合，而是八进制的数字值。在 '[' 和 ']' 字符集合内，任何数字转义都被看作是字符。

\A

只匹配字符串开始。

\b

匹配空字符串，但只在单词开始或结尾的位置。一个单词被定义为一个单词字符的序列。注意在通常情况下，\b 被定义为 \w 和 \W 字符之间的边界（反之亦然），或是 \w 和字符串开始或结尾之间的边界。这意味着 r'\bat\b' 将匹配 'at', 'at.', '(at)' 和 'as at ay' 但不匹配 'attempt' 或 'atlas'。

Unicode (str) 模式中默认的单词类字符是 Unicode 字母数字和下划线，但这可以通过使用 ASCII 旗标来改变。如果使用了 LOCALE 旗标则单词边界将根据当前语言区域来确定。

备注：在一个字符范围内，\b 代表退格符，以便与 Python 的字符串字面值保持兼容。

\B

匹配空字符串，但仅限于它不在单词的开头或结尾的情况。这意味着 r'at\B' 将匹配 'athens', 'atom', 'attorney'，但不匹配 'at', 'at.' 或 'at!'。 \B 与 \b 正相反，这样 Unicode (str) 模式中的单词类字符是 Unicode 字母数字或下划线，但这可以通过使用 ASCII 旗标来改变。如果使用了 LOCALE 旗标则单词边界将根据当前语言区域来确定。

备注：请注意 \B 不会匹配空字符串，这与其他编程语言如 Perl 的 RE 实现不同。此行为是出于兼容性考虑而保留的。

\d

对于 Unicode (str) 样式：

匹配任意 Unicode 十进制数码（也就是说，任何属于 Unicode 字符类别 [Nd] 的字符）。这包括 [0-9]，还包括许多其他的数码类字符。如果使用了 ASCII 旗标则匹配 [0-9]
对于8位(bytes)样式：

匹配 ASCII 字符集内的任意十进制数码；这等价于 [0-9]。

\D

匹配不属于十进制数码的任意字符。这与 \d 正相反。

如果使用了 ASCII 旗标则匹配 [^0-9]

\s

对于 Unicode (str) 样式：

匹配 Unicode 空白字符（如 str.isspace() 所定义的）。这包括 [ \t\n\r\f\v]，还包括许多其他字符，例如许多语言中由排版规则约定的非中断空白字符。如果使用了 ASCII 旗标则匹配 [ \t\n\r\f\v]。
对于8位(bytes)样式：

匹配ASCII中的空白字符，就是 [ \t\n\r\f\v] 。

\S

匹配不属于空白字符的任意字符。这与 \s 正相反。

如果使用了 ASCII 旗标则匹配 [^ \t\n\r\f\v]

\w

对于 Unicode (str) 样式：

匹配 Unicode 单词类字符；这包括所有 Unicode 字母数字类字符 (由 str.isalnum() 定义)，以及下划线 (_)。如果使用了 ASCII 旗标则匹配 [a-zA-Z0-9_]。
对于8位(bytes)样式：

匹配在 ASCII 字符集中被视为字母数字的字符；这等价于 [a-zA-Z0-9_]。如果使用了 LOCALE 旗标，则匹配在当前语言区域中被视为字母数字的字符以及下划线。

\W

匹配不属于单词类字符的任意字符。这与 \w 正相反。在默认情况下，将匹配除下划线 (_) 以外的 str.isalnum() 返回 False 的字符。

如果使用了 ASCII 旗标则匹配 [^a-zA-Z0-9_]。

如果使用了 LOCALE 旗标，则匹配在当前语言区域中不属于字母数字且不为下划线的字符。

\Z

只匹配字符串尾。

Python 字符串字面值支持的大多数转义序列也被正则表达式解析器所接受:

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\

（注意 \b 被用于表示词语的边界，它只在字符集合内表示退格，比如 [\b] 。）

'\u', '\U' 和 '\N' 转义序列仅在 Unicode (str) 模式中可被识别。在字节串模式中它们会导致错误。未知的 ASCII 字母转义符被保留在未来使用并会被视为错误。

八进制转义包含为一个有限形式。如果首位数字是 0，或者有三个八进制数位，那么就认为它是八进制转义。其他的情况，就看作是组引用。对于字符串文本，八进制转义最多有三个数位长。

在 3.3 版本发生变更: 增加了 '\u' 和 '\U' 转义序列。

在 3.6 版本发生变更: 由 '\' 和一个ASCII字符组成的未知转义会被看成错误。

在 3.8 版本发生变更: 增加了 '\N{*name*}' 转义序列。与在字符串字面值中一样，它扩展了指定的 Unicode 字符 (例如 '\N{EM DASH}')。

参考文档：《re --- 正则表达式操作》

Python类型提示简介

Thu, 05 Jun 2025 13:40:35 +0800

Python中的类型提示是一种特殊的语法，这种语法能够显式声明一个变量的类型。通过显式声明变量类型，不仅使得代码可读性变高了，还能够让编辑器为我们编码提供更多的支持。

一、类型声明

类型声明主要作用在函数的参数以及返回值上。

1、简单类型

简单类型包含str、int、float、bool、bytes 五种类型，这些类型都是python标准类型。以下是一个例子：

def get_items(item_a: str, item_b: int, item_c: float, item_d: bool, item_e: bytes):
    return item_a, item_b, item_c, item_d, item_d, item_e

2、泛型类型

Python中的dict、list、set以及tuple类型都是能够包含其它类型值的数据结构，可以直接使用在方法参数上对参数进行标记：

def test(list1: list):
    print(list1)

但是这种方式不能有效标记出来list列表中每一项的类型（3.9+版本已经解决这个问题），可以使用typing模块解决这个问题。

List

接下来让我们定义一个str类型的list列表

在3.9+版本，可以直接使用list[type]，这表示列表中每个元素都是type类型：

def process_items(items: list[str]):
    for item in items:
        print(item)

但是更通用的是使用typing模块，这种在3.8+版本均通用：

from typing import List


def process_items(items: List[str]):
    for item in items:
        print(item)

Tuple

Tuple是typing模块的元组类型类， Tuple[int, int, str]表示元组有三个元素，分别是int、int、str类型。

在3.9+版本：

def process_items(items_t: tuple[int, int, str]):
    return items_t

在3.8+版本：

from typing import Tuple


def process_items(items_t: Tuple[int, int, str]):
    return items_t

Set

Set是typing模块的集合类型类，Set[int]表示集合中的每个元素都是int类型。

3.9+版本：

def process_items(items_s: set[bytes]):
    return  items_s

3.8+版本：

from typing import Set


def process_items(items_s: Set[bytes]):
    return items_s

Dict

Dict是typing模块的字典类型类，Dict[int,str]表示字典中的key都是int类型，value都是str类型。

3.9+版本：

def process_items(prices: dict[str, float]):
    for item_name, item_price in prices.items():
        print(item_name)
        print(item_price)

3.8+版本：

from typing import Dict


def process_items(prices: Dict[str, float]):
    for item_name, item_price in prices.items():
        print(item_name)
        print(item_price)

Union

一个变量可能有几种类型，比如int、str，可以使用typing 模块的Union类表示该变量是某几个类型的其中一个类型。比如Union[int,str]表示可能是int类型，也可能是str类型，但是只可能是其中一种。在3.10版本以前只能使用Union类来表示这种行为，3.10版本引入了新语法，str|int即可表示Union[str,int]，两者是等价的。

3.6+版本：

from typing import Union


def process_item(item: Union[int, str]):
    print(item)

3.10+版本：

def process_item(item: int | str):
    print(item)

Possibly None

在 Python 中，None 是一个特殊的单例对象，它是 NoneType 类型的唯一实例，用于表示“空”或“无值”。我们定义一个变量：name，它可能是str类型，也可能是None类型。在3.6+版本，可以使用typing模块的Optional来表达这种语义：

from typing import Optional


def say_hi(name: Optional[str] = None):
    if name is not None:
        print(f"Hey {name}!")
    else:
        print("Hello World")

Optional[Something]实际上等价于Union[Something, None]，它是一种简化写法，在3.10+版本，可以更进一步写成Something | None。

3.6+版本Union写法：

from typing import Union


def say_hi(name: Union[str, None] = None):
    if name is not None:
        print(f"Hey {name}!")
    else:
        print("Hello World")

3.10+新语法更简洁：

def say_hi(name: str | None = None):
    if name is not None:
        print(f"Hey {name}!")
    else:
        print("Hello World")

疑问1：None是NoneType类型，Union[str, None] = None的写法不对吧，应该写成Union[str, NoneType] = None才对。

答：在 Python 的类型注解中，None 和 NoneType 实际上是等价的，None 可以直接代表 NoneType，因此 Union[str, None] 和 Union[str, NoneType] 语义上是完全相同的。另外NoneType需要额外导入from types import NoneType，所以使用Union[str, None]写法更加简洁。

疑问2：name:Optional[str]=None 写法是否可以简化写成name:str = None

答：不可以，Optional[str]=None实际上就是Union[str,None]=None，两个None的意思不一样，不可省略。Union[str, None] 或 Optional[str]明确表示 name 可以是字符串或 None，语义表达更明确；而=None则是为它赋值了默认值为None，这样可以在不传name参数的时候为name赋予默认值None。实际上None是NoneType类型，为str类型的参数赋值None可能会出现类型不匹配的问题。

疑问3：Optional[str]和Union[str,None]，应该使用哪一种写法？

我认为应当使用Union[str,None]这种写法，这种写法虽然更繁琐一些，但是它具有更高的可读性；Optional[str]会给人一种错觉，它是可有可无的，而实际上并非这样，它必须有值而且是str或者None的一种。

举个例子：

from typing import Optional


def say_hi(name: Optional[str]):
    print(f"Hey {name}!")

name参数是Optional(可选的)，但是实际上它并非可选的（Optional），如果直接调用say_hi() 则会报错，因为name参数未传递。

二、自定义类类型

这个比较简单了，我们自定义一个类Person：

class Person:
    def __init__(self, name: str):
        self.name = name

在某个方法传递Person类的实例one_person，则可以这样写：

def get_person_name(one_person: Person):
    return one_person.name

在编辑器中能得友好的提示：

三、Pydantic models

Pydantic 是一个基于 Python 类型注解的数据验证和解析库，广泛应用于 API 开发、配置管理等领域。使用前需要先安装依赖：

pip install pydantic

看一看Pydantic的基本使用：

from datetime import datetime
from typing import Union

from pydantic import BaseModel


class User(BaseModel):
    id: int
    name: str = "John Doe"
    signup_ts: Union[datetime, None] = None
    friends: list[int] = []


external_data = {
    "id": "123",
    "signup_ts": "2017-06-01 12:22",
    "friends": [1, "2", b"3"],
}
user = User(**external_data)
print(user)
# > User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]
print(user.id)
# > 123

使用时要继承BaseModel类，每个字段可以都使用类型提示加以说明，这样在创建实例的时候Pydantic会将输入自动转换为合适的类型值。比如输入的id是字符串类型的123，由于User类定义的id是int类型，所以会被自动转换为int类型。

更多Pydantic的使用可以参考官方文档：https://docs.pydantic.dev/2.3/usage/models/

四、使用元数据注解的类型提示

在Python中可以使用Annotated提供类型提示功能的同时提供元数据信息。

在3.8+版本，Annotated需要引入typing_extensions 模块才能使用：

from typing_extensions import Annotated


def say_hello(name: Annotated[str, "this is just metadata"]) -> str:
    return f"Hello {name}"

但是在3.9+版本，Annotated成为了标准库的一部分，所以可以通过typing模块直接导入。

from typing import Annotated


def say_hello(name: Annotated[str, "this is just metadata"]) -> str:
    return f"Hello {name}"

Annotated的第一个参数是类型，剩余其它参数都是metadata数据。对于Python来说，它不会对Annotated做任何事情，剩余的元数据信息则在不同的框架中有不同的作用，比较典型的比如在langchain框架中：

import json
from typing import List

from langchain_core.tools import tool
from typing_extensions import Annotated


@tool
def tool(
        a: Annotated[int, "scale factor"],
        b: Annotated[List[int], "list of ints over which to take maximum"],
) -> int:
    """Multiply a by the maximum of b."""
    return a * max(b)


if __name__ == '__main__':
    print(f"Name: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"args schema: {json.dumps(tool.args, indent=4)}")
    print(f"returns directly?: {tool.return_direct}")

以上代码示例中定义了一个tool，a和b的元数据信息会被langchain框架解析用于说明两个参数的作用并提交给大模型，以让大模型理解两个参数该如何传递。

五、参考文档

https://fastapi.tiangolo.com/python-types/

Python脚本：合并mp4和m4a文件

Fri, 23 May 2025 11:28:16 +0800

这个需求产生于B站视频下载下来之后是分开的两个文件：没有声音的mp4视频文件和m4a音频文件。如何下载B站视频，可以参考 Bilibili-Evolved 的使用教程。

一、视频下载

Bilibili-Evolved脚本生效以后，就可以下载B站视频了：

默认下载格式是音画分离的，点击开始会看到两个下载按钮

点击后浏览器会直接下载

二、音视频合并

音视频合并需要使用到工具ffmpeg，使用该命令行工具只需要一行命令就可以合并音视频文件：

ffmpeg -i "file1" -i "file2" -vcodec copy -acodec copy "target_file"

命令很简单，但是每次合并都要拼写这个命令还是很麻烦的，所以这里写了个python脚本来实现

1、python脚本实现音视频合并

import os
import argparse
from pathlib import Path

parser = argparse.ArgumentParser(
    prog='merge_mp4_m4a',
    description='合并mp4和m4a文件脚本',
    epilog='Copyright(r), 2025'
)
parser.add_argument('input', help='m4a文件路径')
# 解析参数
args = parser.parse_args()


def do_merge_file(mp4_file: Path, m4a_file: Path, target_file: Path):
    command = f"""
    ffmpeg -i "{mp4_file.absolute()}" -i "{m4a_file.absolute()}" -vcodec copy -acodec copy "{target_file.absolute()}"
    """
    os.system(command)


def do_merge_mp4_m4a_files():
    input_m4a_path = args.input
    file = Path(input_m4a_path)
    name = file.name.split(".")[0]
    mp4_file = file.parent.joinpath(Path(name + ".mp4"))
    m4a_file = Path(input_m4a_path)
    target_file = file.parent.joinpath(Path(name + "_.mp4"))
    do_merge_file(mp4_file, m4a_file, target_file)
    m4a_file.unlink()
    mp4_file.unlink()
    print(f"output file ={target_file.absolute()}")


if __name__ == '__main__':
    do_merge_mp4_m4a_files()

脚本很简单，它做了如下事情：

从命令行接受m4a文件路径参数
根据文件名推导出mp4文件名称
合并m4a和mp4文件，合并后的文件以文件名_.mp4命名。
删除两个源文件。

现在我们将脚本保存为script.py文件，将其复制到和源文件的同级目录，执行命令python script.py "【无损音质】一生所爱 - 卢冠廷.m4a"

OK，现在已经实现了音视频合并，但是使用起来感觉还不是很方便，将该功能加到右键菜单怎么样？只需要对着m4a文件右键，执行命令即可实现对两个文件的合并：

这就要使用到修改注册表相关的功能了。

2、右键m4a文件执行python脚本合并文件

首先，将python脚本保存到D:\system_script\m4a，防止误删除python脚本导致脚本不可用。

接下来修改注册表，实现对着m4a文件右键后显示“合并同名的MP4文件”菜单，点击后执行script脚本。

Windows+R组合键，输入regedit，进入注册表管理页，打开路径：计算机\HKEY_CLASSES_ROOT\SystemFileAssociations\.m4a

如果.m4a目录下没有shell，则新建项shell。

在shell文件夹下新建项：MergeMp4File，选中后右侧修改默认值为“合并同名的MP4文件”，然后新建字符串值icon，值为python的路径，我的是D:\ProgramFiles\anaconda3\python.exe，完成这一步骤后的注册表：

完成上面的步骤之后，对着m4a文件右键就能看到“合并同名的MP4文件”选项了，图标是python程序的样子。

接下来配置真正执行命令的动作。

在MergeMp4File下新增项command，修改默认值为

D:\ProgramFiles\anaconda3\python.exe D:\system_script\m4a\script.py "%1"

做完这一步后的注册表：

三、运行效果

这样合并两个文件就方便多了。

END.

Win10映射网络驱动器导致的文件资源管理器无响应问题解决方案

Thu, 22 May 2025 16:54:04 +0800

已经有很长时间了，打开我的电脑或者Windows+E快捷键打开文件资源管理器之后系统长时间无响应：

排查了好久终于发现了原来是因为我挂载了很多网络硬盘：

这些网络硬盘都是家庭内网IP挂载的，正常在家使用一点问题没有，但是笔记本拿到公司以后，换了公司网络，这些网络硬盘就都歇菜了。。歇菜就歇菜吧，Windows似乎有什么机制，不连接上不罢休，连带着其它正常的本地分区都显示不出来了，然后就无限loading进度条。。

问题来了，如何解决呢？难道每次去公司前把这些网络硬盘卸载？太麻烦了。这个问题折磨了我好久，终于在今天突然发现了解决方案：把“网络位置”给折叠起来，没错，就这么简单：

这个折叠动作是会被持久化记忆的，下次打开资源管理器还是折叠状态，而且只要是折叠状态，Windows就不会尝试连接网络硬盘了。对此，我只想说一句 MMP 表达下心情。。。。。。

END.

详解Python中的高级特性：切片

Thu, 15 May 2025 16:06:16 +0800

Python 中的切片（Slicing）操作是一种高效且灵活的数据访问方式，主要用于序列类型（如列表、字符串、元组等）。它允许通过指定起始、结束和步长来截取序列的子集。其基本语法如下所示：

sequence[start:stop:step]

start：起始索引（包含），默认为 0。
stop：结束索引（不包含），默认为序列长度。
step：步长（可选），默认为 1，值表示步长；正负表示方向

一、特性

(1) 索引规则

正向索引：从 0 开始，左到右。
负向索引：从 -1 开始（倒数第一个），右到左。

(2) 默认值

省略 start：从序列开头开始（0）。
省略 stop：截取到序列末尾（包括最后一个元素）。
省略 step：默认为 1（连续截取）。

(3) 步长（step）

正步长：从左到右截取。
负步长：从右到左截取（可实现逆序）。

二、常见操作示例

(1) 基本截取

s = [0, 1, 2, 3, 4, 5]
print(s[1:4])    # [1, 2, 3]（包含1，不包含4）
print(s[:3])     # [0, 1, 2]（从开头到索引2）
print(s[3:])     # [3, 4, 5]（从索引3到末尾）

(2) 负索引

print(s[-3:])     # [3, 4, 5]（倒数第3个到末尾）
print(s[:-2])     # [0, 1, 2, 3]（开头到倒数第3个）

(3) 步长应用

print(s[::2])     # [0, 2, 4]（每隔1个取1个）
print(s[::-1])    # [5, 4, 3, 2, 1, 0]（逆序）
print(s[1:5:2])   # [1, 3]（从1到4，步长2）

(4) 字符串切片

text = "Python"
print(text[1:4])  # "yth"
print(text[::-1]) # "nohtyP"

三、注意事项

越界安全：切片索引超出范围时自动截断，不会报错。

s = [1, 2, 3]
print(s[0:10])  # [1, 2, 3]（自动限制到有效范围）

浅拷贝：切片返回的是新对象，但对可变序列的修改可能影响原数据（如嵌套列表）。
不可变序列：字符串、元组的切片会生成新对象，原对象不可变。

四、高级技巧

(1) 赋值与修改

s = [0, 1, 2, 3]
s[1:3] = [10, 20]  # 替换子序列 → [0, 10, 20, 3]
s[::2] = [100, 200] # 按步长赋值 → [100, 10, 200, 3]

(2) 删除元素

s = [0, 1, 2, 3]
s[1:3] = []  # 删除索引1-2 → [0, 3]

五、总结

操作	示例	效果
基本切片	`s[1:4]`	截取索引1到3的子序列
逆序	`s[::-1]`	反转序列
步长截取	`s[::2]`	每隔1个元素取1个
负索引	`s[-3:]`	截取最后3个元素
赋值与修改	`s[1:3]=[10,20]`	替换指定范围的元素

注：以上内容由LLM生成

远程Windows开机：WoL（Wake-on-Lan）客户端Python实现

Mon, 21 Apr 2025 14:25:31 +0800

远程Windows开机实现之前已经使用Java实现过了（详情见《远程Windows开机：WoL（Wake-on-Lan）客户端Java实现》），现在使用Python重新实现，当然，需要重新复习下网络唤醒的原理：

借助WoL技术（Wake-on Lan）可以将电脑远程开机，关于Wol，可以参考维基百科：《网络唤醒》。它的基本原理就是支持Wol技术的网卡在电脑关机之后，网卡还有微弱的供电，当它发现网络广播的内容中有特定的“魔法数据包”，并且经过解析发现它所指的地址是自身所处的电脑时，网卡就会通知机内的主板、电源供应器，开始进行开机（或唤醒）的程序。

具体来说，只要发送特定格式的UDP广播数据包到子网中，就能将计算机唤醒，数据包格式：

FF FF FF FF FF FF FF	MAC 地址 × 16	4-6字节的密码（可空）

完整Python代码如下：

import socket
import os

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 启用广播
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

data = "FFFFFFFFFFFF" + "58112208850B" * 16 + "000000000000"

s.sendto(bytes.fromhex(data), ('192.168.3.255', 9))

s.close()
os.system("pause")

if __name__ == '__main__':
    pass

可以看到Python版本的代码非常简洁，而且作为脚本语言不需要编译打包，直接复制到桌面上就可以随时用了，Python是天下第一好的编程语言！（对不起Java，我叛变了）

大模型开发之langchain0.3（五）：手动干预方法调用

Thu, 17 Apr 2025 11:23:05 +0800

本篇文章讨论下如何添加“人机交互（human-in-the-loop）”动作到方法调用的流程中，翻译成大白话，就是怎样手动干预方法调用。

在之前的文章《大模型开发之langchain0.3（三）：方法调用》中，已经说明了大模型会根据提示词信息自己决定调用什么方法，现在不直接调用方法了，在调用方法前，必须先得到我的同意才行。如何实现该功能呢？

一、方法调用中人机交互原理

我们先回顾下方法调用的原理：

上图中，在❷处大模型告诉用户应该调用什么方法；用户在❸处执行方法调用。我们在❷和❸之间加上审核的逻辑，就可以干预方法执行了。

二、CLI人机交互实现

代码实现如下：

import json
from typing import List, Dict

from langchain.chat_models import init_chat_model
from langchain_core.messages import AIMessage
from langchain_core.tools import tool


class NotApproved(Exception):
    """Custom exception."""


def human_approval(msg: AIMessage) -> AIMessage:
    """Responsible for passing through its input or raising an exception.

    Args:
        msg: output from the chat model

    Returns:
        msg: original output from the msg
    """
    tool_strs = "\n\n".join(
        json.dumps(tool_call, indent=4) for tool_call in msg.tool_calls
    )
    input_msg = (
        f"Do you approve of the following tool invocations\n\n{tool_strs}\n\n"
        "Anything except 'Y'/'Yes' (case-insensitive) will be treated as a no.\n >>>"
    )
    resp = input(input_msg)
    if resp.lower() not in ("yes", "y"):
        raise NotApproved(f"Tool invocations not approved:\n\n{tool_strs}")
    return msg


def call_tools(msg: AIMessage) -> List[Dict]:
    """Simple sequential tool calling helper."""
    tool_map = {tool.name: tool for tool in tools}
    tool_calls = msg.tool_calls.copy()
    for tool_call in tool_calls:
        tool_call["output"] = tool_map[tool_call["name"]].invoke(tool_call["args"])
    return tool_calls


@tool
def count_emails(last_n_days: int) -> int:
    """Dummy function to count number of e-mails. Returns 2 * last_n_days."""
    return last_n_days * 2


@tool
def send_email(message: str, recipient: str) -> str:
    """Dummy function for sending an e-mail."""
    return f"Successfully sent email to {recipient}."


if __name__ == '__main__':
    llm = init_chat_model("gpt-4o-mini", model_provider="openai")
    tools = [count_emails, send_email]
    llm_with_tools = llm.bind_tools(tools)
    chain = llm_with_tools | human_approval | call_tools
    try:
        result = chain.invoke("how many emails did i get in the last 5 days?")
        print(json.dumps(result, indent=4))
    except NotApproved as e:
        print()
        print(e)

以上代码是官方给出的控制台版本代码案例，通过构建chain调用链，在中间加上human_approval逻辑实现人工干预方法调用；如果输入Y/Yes之外的字符，将会抛出异常中断调用链的后续执行：

如果输入Y，则会输出带有output字段的tool_call信息：

三、langchain人机交互的局限性

本篇文章案例来自于官方网站：https://python.langchain.com/docs/how_to/tools_human/

官方网站在开头就明确说了：强烈建议使用langgraph实现人机交互功能，详情参考：https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/

从以上代码中已经可以看得出直接基于langchain的方法调用实现人机交互还是挺麻烦的，方法调用要手动调用，手动处理结果等，使用langgraph几乎能全自动解决所有问题。

END.

Python脚本：Typora+minio实现markdown图片自动上传

Wed, 16 Apr 2025 18:00:40 +0800

在之前的一篇文章中，已经实现了java版本的Typora图片自动上传功能：markdown编辑器typora本地图片上传到自己的服务器

现在使用Python+minio重新实现该功能，比Java版本精简了太多代码了

需要的依赖：

pip install minio

脚本如下：

import argparse
import mimetypes
import uuid
from datetime import date
from urllib.request import urlopen

from minio import Minio

parser = argparse.ArgumentParser(
    prog='typora_upload_image',
    description='typora上传图片脚本',
    epilog='Copyright(r), 2025'
)
parser.add_argument('urls', nargs='+', help='一个或多个URL地址')

client = Minio(
    "127.0.0.1:9000",
    access_key="{your access key}",
    secret_key="{your secret key}",
    secure=False
)


def get_file_path(path):
    now = date.today()
    return "public/" \
           + str(now.year) + "/" \
           + (str(now.month) if now.month > 10 else ("0" + str(now.month))) + "/" \
           + (str(now.day) if now.day > 10 else ("0" + str(now.day))) + "/" \
           + str(uuid.uuid4()).replace("-", "") + "." \
           + path.split(".")[-1]


def upload_to_minio(path: str) -> str:
    """
    上传图片到minio
    :param path: 源url，可能是本地图片，也可能是网络图片
    :return: minio的图片地址
    """
    file_path = get_file_path(path)
    mimetype, encoding = mimetypes.guess_type(path)
    if path.startswith("http"):
        bynary_io = urlopen(path)
        client.put_object(
            bucket_name="blog",
            object_name=file_path,
            data=bynary_io,
            content_type=mimetype,
            length=-1,
            part_size=10 * 1024 * 1024,
        )
    else:
        client.fput_object(
            bucket_name="blog",
            object_name=file_path,
            file_path=path,
            content_type=mimetype
        )
    return file_path


if __name__ == '__main__':
    urls = parser.parse_args().urls
    for url in urls:
        uploaded_url = upload_to_minio(url)
        print("https://127.0.0.1:9000/blog/" + uploaded_url)

使用者需修改以下代码：

minio地址和端口号
access_key和secret_key
公开的特定地址前缀，比如/public前缀，这需要在minio中设置

将python D:\script.py 命令填写到文件->偏好设置->图像->命令

运行效果：

Python基础：装饰器

Wed, 16 Apr 2025 13:38:02 +0800

装饰器是Python中最强大且优雅的特性之一，它允许你在不修改函数或类源代码的情况下，动态地扩展它们的功能。装饰器本质上是一个接受函数作为参数并返回新函数的高阶函数。对应到java，其形式和注解切面非常相似。

一、装饰器的基本使用

下面用一个例子解释装饰器

def log(fun):
    def wrapper(*args, **kwargs):
        print("方法调用前")
        result = fun(*args, **kwargs)
        print("方法调用后")
        return result

    return wrapper


@log
def hello():
    print("Hello,World")


if __name__ == '__main__':
    hello()

运行结果：

方法调用前
Hello,World
方法调用后

上面的代码执行了hello方法，hello方法的@log注解实际上相当于：

hello = log(hello)
hello()

log方法返回的方法实际上已经变成了wrapper方法，而wrapper方法接收的参数是*args, **kwargs，所以它可以接受任意参数。

来看下它的等价代码：

def log(fun):
    def wrapper(*args, **kwargs):
        print("方法调用前")
        result = fun(*args, **kwargs)
        print("方法调用后")
        return result

    return wrapper


def hello():
    print("Hello,World")


if __name__ == '__main__':
    hello = log(hello)
    hello()

运行结果和装饰器的运行结果是一样的。

二、装饰器传参

如果装饰器方法本身需要一些参数控制装饰器的行为，该如何传参呢？比如以上的log装饰器，我需要传一个参数level，形式如下：

@log(level="INFO")
def hello():
    print("Hello,World")

打印日志的时候需要将该字符串放到日志前面，如何实现？

这里需要用到三层嵌套，修改后的代码如下

def log(level):
    def decorator(fun):
        def wrapper(*args, **kwargs):
            print(f"{level}:方法调用前")
            result = fun(*args, **kwargs)
            print(f"{level}:方法调用后")
            return result

        return wrapper
    return decorator


@log(level="INFO")
def hello():
    print("Hello,World")


if __name__ == '__main__':
    hello()

运行结果：

INFO:方法调用前
Hello,World
INFO:方法调用后

此时的hello()方法调用等价于以下代码：

hello = log(level="INFO")(hello)
hello()

完整的等价代码如下所示：

def log(level):
    def decorator(fun):
        def wrapper(*args, **kwargs):
            print(f"{level}:方法调用前")
            result = fun(*args, **kwargs)
            print(f"{level}:方法调用后")
            return result

        return wrapper

    return decorator


# @log(level="INFO")
def hello():
    print("Hello,World")


if __name__ == '__main__':
    hello = log(level="INFO")(hello)
    hello()

三、函数签名变更问题

装饰器传参的问题也解决了，接下来看看装饰器引发的函数签名变化问题，运行以下代码，hello方法的__name__属性还是hello吗？

def log(level):
    def decorator(fun):
        def wrapper(*args, **kwargs):
            print(f"{level}:方法调用前")
            result = fun(*args, **kwargs)
            print(f"{level}:方法调用后")
            return result

        return wrapper

    return decorator


@log(level="INFO")
def hello():
    print("Hello,World")


if __name__ == '__main__':
    print(hello.__name__)

输出：

wrapper

没错，hello的方法名已经变成了wrapper，这对于某些依赖函数签名的代码执行就会出错。

首先想到的解决方案就是复制hello方法的__name__到wrapper方法。。实际上使用内置的functools模块可以解决这个问题，只需要在wrapper方法上使用@functools.wraps(log)标记一下即可，来看下它的使用：

import functools


def log(level):
    def decorator(fun):
        @functools.wraps(log)
        def wrapper(*args, **kwargs):
            print(f"{level}:方法调用前")
            result = fun(*args, **kwargs)
            print(f"{level}:方法调用后")
            return result

        return wrapper

    return decorator


@log(level="INFO")
def hello():
    print("Hello,World")


if __name__ == '__main__':
    print(hello.__name__)

输出：

log

参考文档：https://liaoxuefeng.com/books/python/functional/decorator/index.html

END.

详解python中的*符号

Wed, 09 Apr 2025 23:47:43 +0800

在Python中，星号（*）是一个多用途运算符，具有多种使用场景。它在函数定义、解包操作、算术运算、模块导入等多个领域扮演重要角色。

1、算术运算符

单星号 *：用于数值的乘法或幂运算中的相乘。

result = 2 * 3   # 输出6

双星号 **：表示幂运算（指数）：

result = 2 ** 3  # 输出8（2的三次方）

另外，比较特殊的，单 * 在左侧为字符串的情况下表示“复制”N次的意思，其实这就是乘法运算。

result = "A"*3  # 输出AAA（3个A）

2、函数参数

关于函数参数，可以先参考文章：https://liaoxuefeng.com/books/python/function/parameter/index.html

符号*函数参数这里有两个用处。

*args：位置参数收集，允许函数接受任意数量的位置参数，并将其存储为一个元组。

def my_func(*args):
    print(args)
my_func(1, 2, 3)  # 输出：(1, 2, 3)

**kwargs：关键字参数收集，允许函数接受任意数量的关键字参数（键值对），并存储为一个字典。

def my_func(**kwargs):
    print(kwargs)
my_func(a=1, b=2)  # 输出：{'a': 1, 'b': 2}

3、参数解包

解包操作允许将序列（如列表、元组、字典）展开为独立的参数。

函数调用中的解包

*解包可迭代对象（如列表、元组）为位置参数：

def add(a, b): 
    return a + b
nums = [3, 5]
print(add(*nums))  # 输出8，等价于 add(3, 5)

**解包字典为关键字参数：

config = {'width': 800, 'height': 600}
def configure(width, height):
    return f"Width: {width}, Height: {height}"
print(configure(**config))  # 输出: "Width: 800, Height: 600"

序列解构

用 * 捕获剩余元素：

# 解构列表
a, *rest = [1, 2, 3, 4]
print(a)    # 1
print(rest)  # [2, 3, 4]
# 解构元组
first, *middle, last = (10, 20, 30, 40)
print(first)   # 10
print(middle)  # [20, 30]
print(last)    # 40

4、模块导入

from module import * 导入模块中的所有公有符号（除以下划线开头的名称）。不建议在大型项目中使用，因为它可能污染命名空间。

from math import *
print(sqrt(16))  # 输出4.0

5、字典与集合的解包

合并字典

在Python3.5之后，可以使用如下方式合并字典

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged = {**dict1, **dict2}  # 输出: {'a':1, 'b':3, 'c':4}

实际上是先解包，再合并。

Python3.9之后，可以使用|符号合并字典

merged = dict1 | dict2  # 等同于 {**dict1, **dict2}

合并集合或列表

用 * 展开可迭代对象：

# 合并列表
list1 = [1, 2]
list2 = [3, 4]
combined = [*list1, *list2]  # 输出：[1, 2, 3, 4]
# 合并集合
set1 = {1, 2}
set2 = {3, 4}
combined_set = {*set1, *set2}  # 输出：{1,2,3,4}

6、参数分隔符

在函数参数列表中，单独的 * 用于分隔位置参数和关键字参数：

例如以下方法：

def add_human_in_the_loop(
    tool: Callable | BaseTool,
    *,
    interrupt_config: HumanInterruptConfig = None,
) -> BaseTool

这表示 tool 可以是位置参数或关键字参数
但 interrupt_config 必须是关键字参数（调用时必须写成 interrupt_config=值 的形式）

Python基础：协程

Wed, 09 Apr 2025 17:36:28 +0800

一、生成器

在Python中，生成器（Generator）是一种用于创建迭代器的简洁且高效的工具，能够按需生成值而非一次性加载所有数据到内存。举个例子：

g = (x * x for x in range(10))

上述代码定义了一个生成器g，它和列表生成式的用法非常相似，列表生成式：

L = [x * x for x in range(10)]

不同的是，生成器只是保存了一个“算法”，它并不会展开计算最后得到一个列表，生成器中的每一个值都是根据前一个值“推导”出来的，只有用到的时候才会计算。‌

1、创建生成器

第一种方式是上面提到的创建方式：g = (x * x for x in range(10))，这种方式是生成器表达式，能够快速创建生成器表达式；

第二种方式是通过创建一个普通函数，然后配合yield关键字创建，下面的代码创建了一个斐波那契数列生成器：

def fibonacci(n):
    index, a, b = 0, 0, 1
    while index < n:
        yield a
        a, b = b, a + b
        index = index + 1
    return 'done'

2、生成器迭代

第一种方法：`next`函数。

比如对于g = (x * x for x in range(10)) 生成器，使用next函数遍历代码如下：

g = (x * x for x in range(10))

if __name__ == '__main__':
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g)) #第11次调用会报错

第11次调用开始报错：

0
1
4
9
16
25
36
49
64
81
Traceback (most recent call last):
  File "D:\gitee_my\python-basic-study\02.aio\00.generator_demo.py", line 24, in <module>
    print(next(g))
StopIteration

使用next函数迭代，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。这种迭代方式着实过于变态，正确的方法是使用for循环。

第二种方式： for循环

以斐波那契数列生成器为例：

def fibonacci(n):
    index, a, b = 0, 0, 1
    while index < n:
        yield a
        a, b = b, a + b
        index = index + 1
    return 'done'

遍历该生成器可使用for循环：

g1 = fibonacci(10)
    for i in g1:
        print(i)

使用def+yield的方式定义的生成器，每次执行到 yield 时暂停，返回当前值；下次调用时从暂停的位置继续执行。当函数执行完毕或遇到 return 语句时，抛出 StopIteration 异常，结束迭代；但是for循环方式会消化掉该异常，同时也无法获取return返回值，如果想获取return返回值，只能通过next函数的方式：

def next_iter():
    g1 = fibonacci(6)
    print(next(g1))
    print(next(g1))
    print(next(g1))
    print(next(g1))
    print(next(g1))
    print(next(g1))
    try:
        print(next(g1))  # 第7次调用会报错
    except StopIteration as e:
        print("generator return value:", e.value)

输出：

0
1
1
2
3
5
generator return value: done

3、生成器接收值

yield关键字不仅能返回值，还能接收值。先定义一个生成器：

def value_adjuster():
    current = 0
    while True:
        received = yield current  # 暂停并等待接收值
        print(f"接收到的值：{received}")
        if received is not None:
            current = received  # 更新内部状态
        else:
            current += 1  # 默认自增
            
gen = value_adjuster() #创建生成器实例

该生成器每次接收一个值，如果值不为空，就将其赋值给内部维护的current；否则current值自增。下次循环时将该值返回给调用方。

生成器在调用send方法前需要先初始化，初始化的方法有两种：

方法一：调用next函数初始化，next(gen)

方法二：发送空值，gen.send(None)

测试运行如下代码：

print(next(gen))  # 初始化生成器，输出 0
print(gen.send(10))  # 发送 10，生成器返回 10
print(next(gen))  # 继续执行，输出 11
print(gen.send(5))  # 发送 5，生成器返回 5
print(next(gen))  # 继续执行，输出 6

输出：

0
接收到的值：10
10
接收到的值：None
11
接收到的值：5
5
接收到的值：None
6

可以看到，send方法会向生成器发送一个值，之后接收生成器返回的值；如果没有向生成器发送值，那么yield会接收到None。所以，生成器可以连续的调用send方法：

print(gen.send(10))  # 发送 10，生成器返回 10
print(gen.send(5))  # 发送 5，生成器返回 5

二、协程

协程（Coroutine）是 Python 中实现‌异步编程‌的核心工具，用于编写高性能的 I/O 密集型代码。其核心思想是通过协作式多任务（非抢占式），在单线程内实现并发执行。

协程和线程有什么区别呢？

线程/进程‌：由操作系统调度，存在上下文切换开销，适合 CPU 密集型任务。

‌协程‌：由程序员控制切换点（如 await），无上下文切换开销，适合 I/O 密集型任务（如网络请求、文件读写）。

1、生成器和协程

Python 3.4 前，Python对协程的支持是通过生成器实现的。可以说协程是生成器的一种高级应用，利用 yield 的暂停和参数传递特性实现控制流同步。

实际上上一章节的“生成器接收值”案例正是协程的一个简答案例。接下来以生产者消费者为例说明生成器协程的使用。

单生产者消费者

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'


def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()


c = consumer()
produce(c)

if __name__ == '__main__':
    pass

输出结果如下：

[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 3...
[CONSUMER] Consuming 3...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 4...
[CONSUMER] Consuming 4...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 5...
[CONSUMER] Consuming 5...
[PRODUCER] Consumer return: 200 OK

这个案例比较简单，生产者生产出来发送给消费者，消费者消费完成返回生产者“200 OK”，生产者接收到消息后继续生产；由于只是一个生产者和一个消费者，所以整体过程比较清晰。唯一美中不足的是整个过程串行化，无法看到协程在并行处理中的特点。

接下来看看协程在多生产者多消费者模型中的表现。

多生产者多消费者

import random
import time
from collections import deque


def producer(name, queue, max_items):
    """生产者协程，生成数据并发送给队列"""
    for i in range(max_items):
        item = f"{name}-{i}"
        print(f"生产者 {name} 生产了 {item}")
        time.sleep(random.random() * 0.5)  # 模拟生产时间
        queue.append(item)
        yield  # 暂停，让出控制权


def consumer(name, queue):
    """消费者协程，从队列中消费数据"""
    while True:
        while queue:
            item = queue.popleft()
            print(f"消费者 {name} 消费了 {item}")
            time.sleep(random.random() * 2)  # 模拟消费时间
            yield  # 处理完一个项目后暂停
        yield  # 如果队列为空，也暂停


def scheduler(producers, consumers, max_items):
    """调度器，协调生产者和消费者的执行"""
    producer_done = [False] * len(producers)
    remaining_items = max_items * len(producers)

    # 初始化所有协程
    for p in producers:
        next(p)
    for c in consumers:
        next(c)

    # 主调度循环
    while remaining_items > 0:
        # 随机选择一个生产者
        active_producer_idx = random.randint(0, len(producers) - 1)
        if not producer_done[active_producer_idx]:
            try:
                producers[active_producer_idx].send(None)
            except StopIteration:
                producer_done[active_producer_idx] = True

        # 随机选择一个消费者
        active_consumer_idx = random.randint(0, len(consumers) - 1)
        consumers[active_consumer_idx].send(None)

        # 更新剩余项目计数
        remaining_items = sum(not done for done in producer_done) * max_items


if __name__ == "__main__":
    # 共享队列
    queue = deque()

    # 配置参数
    num_producers = 3
    num_consumers = 2
    items_per_producer = 5

    # 创建生产者和消费者协程
    producers = [
        producer(f"[PRODUCER]-{i}", queue, items_per_producer)
        for i in range(num_producers)
    ]

    consumers = [
        consumer(f"[CONSUMER]-{i}", queue)
        for i in range(num_consumers)
    ]

    # 启动调度器
    scheduler(producers, consumers, items_per_producer)

    print("所有生产消费任务完成!")

上面的代码实际上是串行运行的，因为Python的生成器协程（非asyncio）在单个线程中通过显式调度交替执行，而不是真正的并发。

调度器随机选择要执行的生产者或消费者，当队列为空时，消费者会暂停，当生产者完成所有项目后会停止。

2、asnyc/await 协程

生成器协程不能实现真正的并发，而且运行效率低，Python 3.5（2015年9月）首次支持async/await语法，但此时协程仍需通过asyncio.coroutine装饰器声明；Python 3.7+（2018年6月）进一步优化，协程可通过async def直接声明（无需装饰器），并改进了事件循环（asyncio库）和性能。

当前我的python版本是3.11，所以无须担心可以直接使用最新版本的协程语法。

基本语法

使用 async def 定义协程函数，内部通过 await 挂起执行：

async def fetch_data():
    print("开始获取数据")
    await asyncio.sleep(1)  # 模拟 I/O 操作
    print("数据获取完成")
    return "data"

运行协程

协程必须通过‌事件循环‌运行：

import asyncio


async def fetch_data():
    print("开始获取数据")
    await asyncio.sleep(1)  # 模拟 I/O 操作
    print("数据获取完成")
    return "data"


async def run():
    result = await fetch_data()
    print("结果：", result)


if __name__ == '__main__':
    asyncio.run(run())

运行结果：

开始获取数据
（等待一秒）
数据获取完成
结果： data

多生产者多消费者

现在使用async/await版本的协程重新实现多生产者多消费者

import asyncio
from asyncio import Queue


async def producer(name, queue: Queue, max_items):
    """异步生产者"""
    for i in range(max_items):
        item = f"{name}-{i}"
        print(f"生产者 {name} 生产了 {item}")
        await queue.put(item)
        await asyncio.sleep(1)  # 模拟异步生产


async def consumer(name, queue: Queue):
    """异步消费者"""
    while True:
        item = await queue.get()
        print(f"消费者 {name} 消费了 {item}")
        queue.task_done()
        await asyncio.sleep(1)  # 模拟异步消费


async def run():
    queue: Queue = asyncio.Queue(maxsize=3)  # 限制队列大小实现背压
    producers = [
        asyncio.create_task(producer(f"P-{i}", queue, 5))
        for i in range(3)
    ]
    consumers = [
        asyncio.create_task(consumer(f"C-{i}", queue))
        for i in range(2)
    ]

    await asyncio.gather(*producers)  # 等待所有生产者完成
    await queue.join()  # 等待队列清空
    for c in consumers:  # 取消消费者任务
        c.cancel()


if __name__ == '__main__':
    asyncio.run(run())

可以看到这段代码比生成器版本的写成要精简的多，而且代码也更清晰。代码中使用了asyncio的很多方法，这之后再聊它们的作用。

上述代码可以尝试调整队列的大小以及生产者、消费者的数量以观察供大于求、供小于求等各种情况下的表现。

三、asyncio

asyncio 是 Python 用于编写并发代码的标准库，使用 async/await 语法。它特别适合 I/O 密集型和高并发的网络应用。

1、基本用法

运行协程（同步方法中运行协程）：

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')

# Python 3.7+
asyncio.run(main())

并发运行任务：

async def task(name, seconds):
    print(f"{name} starting")
    await asyncio.sleep(seconds)
    print(f"{name} finished after {seconds}s")

async def main():
    # 方式1: gather
    await asyncio.gather(
        task("A", 2),
        task("B", 1),
        task("C", 3)
    )
    
    # 方式2: create_task + await
    t1 = asyncio.create_task(task("X", 2))
    t2 = asyncio.create_task(task("Y", 1))
    await t1
    await t2

需要特别注意的是：await关键字调用必须在async块中。

2、异步生成器

之前说过可以使用生成器实现协程功能，实际上使用async的协程也可以搭配生成器一起实现异步生成器的功能：

async def async_gen(n):
    for i in range(n):
        await asyncio.sleep(0.5)
        yield i

async def main():
    async for item in async_gen(3):
        print(item)

3、限制并发数

使用semaphore实现限制并发数：

async def worker(semaphore, name):
    async with semaphore:
        print(f"{name} started")
        await asyncio.sleep(2)
        print(f"{name} finished")

async def main():
    semaphore = asyncio.Semaphore(3)  # 最多3个并发
    tasks = [
        asyncio.create_task(worker(semaphore, f"Worker-{i}"))
        for i in range(10)
    ]
    await asyncio.gather(*tasks)

semaphore在Java中是一种共享锁，通过信号量机制实现并发数量控制，在python中也是类似的功能，详情可以查看：详解AQS七：深入理解信号量机制Semaphore

4、同步阻塞队列：Queue

通过queue: Queue = asyncio.Queue(maxsize=3)可以创建一个长度为3的同步阻塞队列，它和java中的BlokingQueue有异曲同工之妙。

put方法：将一个元素放入队列，如果队列已满，就阻塞等待队列空闲。

get方法：从队列中获取并移除一个元素，如果队列为空，就一直阻塞等待直到队列中有元素为止。

task_done方法：高速队列之前get方法取出的任务已经执行完成

join方法：等待队列中的任务全部执行完毕，该方法依赖于task_done方法的执行。

END.

大模型开发之langchain0.3（四）：方法调用进阶

Tue, 08 Apr 2025 14:53:15 +0800

本篇文章将讲解langchain内置的第三方集成工具以及自定义工具的三种方式、自定义Input Schema的三种方式。

一、第三方集成工具

在上一篇文章《大模型开发之langchain0.3（三）：方法调用》中，已经简单介绍过如何自定义工具以及结合支持function calling的大模型使用，本小节将介绍langchain中已经集成各种的第三方工具，这些工具开箱即用，在很多场景下使用起来很方便，不需要我们重复造轮子了。

全部的第三方集成工具列表：https://python.langchain.com/docs/integrations/tools/#all-tools

下面介绍几个常见的经典的工具使用案例。

1、Tavily Search：让大模型支持联网功能

大模型都是默认离线使用的，这导致它们不能获取最新网络上的数据，Tavily Search 则解决了这一痛点。

Tavily Search官网地址：https://tavily.com/

Tavily Search控制台地址：https://app.tavily.com/home

先注册，注册成功之后进入控制台：控制台上显示Tavily Search每个月有1000次的免费额度，这个额度对于学习和实验用足够用了。

复制下来API Key，之后用的到，接下来看看如何使用Tavily Search工具。

Tavily Search langchain文档：https://python.langchain.com/docs/integrations/tools/tavily_search/

第一步：安装依赖

pip install langchain-tavily

第二步：设置环境变量

将之前复制下来的Key设置到环境变量：TAVILY_API_KEY ，注意，设置环境变量之后需要重启PyCharm，这里的重启指的的是关闭PyCharm，然后再打开，而非File->InvalidCaches / Restart 功能，使用restart功能环境变量不会更新。

第三步：工具定义

from langchain_tavily import TavilySearch

tool = TavilySearch(
    max_results=5,
    topic="general",
    # include_answer=False,
    # include_raw_content=False,
    # include_images=False,
    # include_image_descriptions=False,
    # search_depth="basic",
    # time_range="day",
    # include_domains=None,
    # exclude_domains=None
)

接下来按照上一篇文章《大模型开发之langchain0.3（三）：方法调用》中最后的代码，将该工具加入工具列表中：

# Tool 创建
tools = [multiply, tavily_search_tool]

运行代码，尝试问大模型：今天北京的天气如何？观察输出结果。

注意，如果运行报错，修改

trimmer = trim_messages(
    max_tokens=300,
    strategy="last",
    token_counter=model,
    include_system=True,
    allow_partial=False,
    start_on="human",
)

将max_tokens值修改为3000再重试。

2、Wolfram Alpha：让大模型拥有数学计算能力

大模型本身就有数学计算的能力，但是它经常会“算错”，Wolfram Alpha 则赋能大模型让其具有更精准的数学计算的能力。

Wolfram Alpha 官网：https://www.wolframalpha.com/

Langchain Wolframe Alpha文档：https://python.langchain.com/docs/integrations/tools/wolfram_alpha/

注册成功之后在“我的应用程序”中创建AppID，记住AppID，后续用得到。

第一步：环境变量设置

将之前复制的AppID设置到环境变量：WOLFRAM_ALPHA_APPID，注意，设置成功后需要关闭PyCharm然后重新打开。

第二步：安装依赖包

pip install langchain-community==0.3.21 wolframalpha

第三步：定义工具方法

wolframaAlpha = WolframAlphaQueryRun(api_wrapper=WolframAlphaAPIWrapper())

接下来按照上一篇文章《大模型开发之langchain0.3（三）：方法调用》中最后的代码，将该工具加入工具列表中：

tools = [tavily_search_tool, math_tool]

运行代码：

查看后台工具类打印出来的输入：

input math req=3x + 4y = 71, x + y = 20

可以看到，大模型将问题转化成了二元一次方程组，Wolfram Alpha只需要解方程组就好了。

3、其它工具

上述两个例子只做抛砖引玉之用，完整的工具列表可查看文档：https://python.langchain.com/docs/integrations/tools/#all-tools

大多数的第三方工具使用起来都很简单，只需要安装依赖，按照官方教程即可使用。

比如，如何引入维基百科的搜索功能，和Wolfram Alpha相似，只需要一行代码即可：

wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())

二、自定义工具的三种方式

官方文档：How to create tools

创建自定义工具有三种方式：普通方法构建、LangChain Runnable方法构建、继承BaseTool类构建。无论是哪一种构建方式，都需要遵循构建自定义工具的规范：工具方法要由name、description、args_schema、return_direct 四部分组成。

1、自定义工具的组成

一个自定义tool由以下几部分组成：

属性	类型	描述
name	str	当提供给LLM或者agent的时候，需要在工具列表中保持唯一；它最好有比较好的语义含义，这样有利于大模型作出合适的选择
description	str	这个工具是做什么用的。这个描述信息非常重要，大模型或者agent将会使用该信息作为是否调用该方法的依据。
args_schema	pydantic.BaseModel	可选的参数，但是推荐使用；使用该参数可以额外设置一些属性，比如在few-shot模式下给出examples
return_direct	boolean	该参数是agent相关的参数，当为True的时候，agnet执行完方法会立即停止执行并将方法执行的结果返回给用户。

2、方法1：function方法构建Tool

从普通的方法构建中构建Tool在前面的文章《大模型开发之langchain0.3（三）：方法调用》已经演示过了，在普通方法上加上装饰器@tool就可以将普通方法转化为Tool，比如一个简单的加法运算：

from langchain_core.tools import tool


@tool
def tool(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b


if __name__ == '__main__':
    print(type(tool))
    print(f"Name: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"args schema: {tool.args}")
    print(f"returns directly?: {tool.return_direct}")

输出结果：

<class 'langchain_core.tools.structured.StructuredTool'>
Name: tool
Description: Multiply two numbers.
args schema: {'a': {'title': 'A', 'type': 'integer'}, 'b': {'title': 'B', 'type': 'integer'}}
returns directly?: False

可以看到，被@tool装饰器装饰之后的方法，类型从function变成了StructuredTool，因此，tool就有了name、description、args、return_direct等属性。

实际上，如果不想使用@tool装饰器，可以使用StructuredTool直接利用现有方法构建一个工具：

from langchain_core.tools import StructuredTool
import asyncio

def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b


async def amultiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b


calculator = StructuredTool.from_function(func=multiply, coroutine=amultiply)

print(calculator.invoke({"a": 2, "b": 3}))
print(asyncio.run(calculator.ainvoke({"a": 2, "b": 5})))

这样，对于原有的代码都不需要改动，就可以创建出一个工具，但是上述代码缺少了参数说明，LLM调用的时候是否会报错？可以通过额外新增一个参数说明的schema来描述这些信息。

class CalculatorInput(BaseModel):
    a: int = Field(description="first number")
    b: int = Field(description="second number")


def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b


calculator = StructuredTool.from_function(
    func=multiply,
    name="Calculator",
    description="multiply numbers",
    args_schema=CalculatorInput,
    return_direct=True,
    # coroutine= ... <- you can specify an async method if desired as well
)

print(calculator.invoke({"a": 2, "b": 3}))
print(calculator.name)
print(calculator.description)
print(calculator.args)

通过定义CalculatorInput类，对输入参数进行了说明，这样大模型就能理解输入参数是什么意思了从而使得方法调用逻辑不会出错。

3、方法2：从Runnables接口构建Tool

Runnables详解：Runnable interface

官方文档：How to convert Runnables to Tools

Runnable接口是个比较大的话题，简单来说langchain的各种组件比如 language models, output parsers, retrievers, compiled LangGraph graphs 等等都实现了该接口，实现了该接口的组件，可以通过as_tool方法构建Tool：

from langchain_core.language_models import GenericFakeChatModel
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages(
    [("human", "Hello. Please respond in the style of {answer_style}.")]
)

# Placeholder LLM
llm = GenericFakeChatModel(messages=iter(["hello matey"]))

chain = prompt | llm | StrOutputParser()

as_tool = chain.as_tool(
    name="Style responder",
    description="Description of when to use tool."
)

if __name__ == '__main__':
    print(as_tool.args)

输出：

{'answer_style': {'title': 'Answer Style', 'type': 'string'}}

4、方法3：继承BaseTool类构建Tool

通过继承BaseTool类构建Tool需要些更多的代码，但是这是一种能够最大程度掌控工具创建细节的方法。

这种方式在上一节：《第三方集成工具》中无论是Tavily Search还是Wolfram Alpha，均是使用此种方式创建的工具。

import asyncio
from typing import Optional

from langchain_core.callbacks import (
    AsyncCallbackManagerForToolRun,
    CallbackManagerForToolRun,
)
from langchain_core.tools import BaseTool
from langchain_core.tools.base import ArgsSchema
from pydantic import BaseModel, Field


class CalculatorInput(BaseModel):
    a: int = Field(description="first number")
    b: int = Field(description="second number")


# Note: It's important that every field has type hints. BaseTool is a
# Pydantic class and not having type hints can lead to unexpected behavior.
class CustomCalculatorTool(BaseTool):
    name: str = "Calculator"
    description: str = "useful for when you need to answer questions about math"
    args_schema: Optional[ArgsSchema] = CalculatorInput
    return_direct: bool = True

    def _run(
            self, a: int, b: int, run_manager: Optional[CallbackManagerForToolRun] = None
    ) -> str:
        """Use the tool."""
        return a * b

    async def _arun(
            self,
            a: int,
            b: int,
            run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
    ) -> str:
        """Use the tool asynchronously."""
        # If the calculation is cheap, you can just delegate to the sync implementation
        # as shown below.
        # If the sync calculation is expensive, you should delete the entire _arun method.
        # LangChain will automatically provide a better implementation that will
        # kick off the task in a thread to make sure it doesn't block other async code.
        return self._run(a, b, run_manager=run_manager.get_sync())


if __name__ == '__main__':
    multiply = CustomCalculatorTool()
    print(multiply.name)
    print(multiply.description)
    print(multiply.args)
    print(multiply.return_direct)

    print(multiply.invoke({"a": 2, "b": 3}))
    print(asyncio.run(multiply.ainvoke({"a": 2, "b": 3})))

输出：

Calculator
useful for when you need to answer questions about math
{'a': {'description': 'first number', 'title': 'A', 'type': 'integer'}, 'b': {'description': 'second number', 'title': 'B', 'type': 'integer'}}
True
6
6

三、自定义Input Schema的三种方式

官方文档：

How to use chat models to call tools

How to create tools

1、方法1：Python functions

这种方式是通过文档注释的方式声明Input Schema的：

import json

from langchain_core.tools import tool


@tool(parse_docstring=True)
def tool(a: int, b: int) -> int:
    """Add two integers.

    Args:
        a: First integer
        b: Second integer
    """
    return a + b


if __name__ == '__main__':
    print(f"Name: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"args schema: {json.dumps(tool.args, indent=4)}")
    print(f"returns directly?: {tool.return_direct}")

输出：

Name: tool
Description: Add two integers.
args schema: {
    "a": {
        "description": "First integer",
        "title": "A",
        "type": "integer"
    },
    "b": {
        "description": "Second integer",
        "title": "B",
        "type": "integer"
    }
}
returns directly?: False

关键是要使用@tool装饰器，而且要设置parse_docstring属性为true。这种方式的好处是代码简洁，坏处是不够灵活，比如不能明确指定directly的值，工具名字和方法名是绑定的。

2、方法2：Pydantic class

这种方式通过继承BaseModel实现单独的Schema定义

from pydantic import BaseModel, Field
import json

from langchain_core.tools import tool


class AddSchema(BaseModel):
    """Add two integers."""

    a: int = Field(..., description="First integer")
    b: int = Field(..., description="Second integer")


@tool("add tool", args_schema=AddSchema, return_direct=True)
def tool(a: int, b: int) -> int:
    return a + b


if __name__ == '__main__':
    print(f"Name: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"args schema: {json.dumps(tool.args, indent=4)}")
    print(f"returns directly?: {tool.return_direct}")

输出结果：

Name: add tool
Description: Add two integers.
args schema: {
    "a": {
        "description": "First integer",
        "title": "A",
        "type": "integer"
    },
    "b": {
        "description": "Second integer",
        "title": "B",
        "type": "integer"
    }
}
returns directly?: True

Process finished with exit code 0

3、方式3：TypedDict class

我个人比较喜欢这种方式，通过@tool装饰器、文档注释和字段注解相配合共同构建Input Schema。

import json
from typing import List

from langchain_core.tools import tool
from typing_extensions import Annotated


@tool
def tool(
        a: Annotated[int, "scale factor"],
        b: Annotated[List[int], "list of ints over which to take maximum"],
) -> int:
    """Multiply a by the maximum of b."""
    return a * max(b)


if __name__ == '__main__':
    print(f"Name: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"args schema: {json.dumps(tool.args, indent=4)}")
    print(f"returns directly?: {tool.return_direct}")

输出：

Name: tool
Description: Multiply a by the maximum of b.
args schema: {
    "a": {
        "description": "scale factor",
        "title": "A",
        "type": "integer"
    },
    "b": {
        "description": "list of ints over which to take maximum",
        "items": {
            "type": "integer"
        },
        "title": "B",
        "type": "array"
    }
}
returns directly?: False

END.

Python脚本：解决博客园Markdown编辑器提取图片失败问题

Wed, 02 Apr 2025 17:56:16 +0800

博客园的博友们不知道有没有用过Markdown编辑器下方的“提取图片”功能，该功能就是解析Markdown编辑器中的所有图片链接，将其重新上传到博客园，生成博客园的图片链接后替换掉Markdown中的图片链接。功能是不错的功能，但是这个功能非常慢，而且最近总是会失败。

我一开始的解决方案是一个图片一个图片的在编辑器中重新上传（在编辑器中直接上传速度很快），但是这种方法效率太低了。。。为了解决这个问题，我写了一个Python脚本，脚本模拟在编辑器直接上传图片，上传成功后将图片链接替换成接口返回的链接。

一、Python脚本

运行脚本前，需要先安装第三方模块：

pip install requests

完整Python脚本如下所示：

"""
解析markdown文件中的图片并将图片上传到博客园图床，之后替换掉markdown文件中的图片链接

注意：使用该脚本需要替换掉代码中的cookie信息
"""

import tkinter as tk
from pathlib import Path
from tkinter import filedialog
import os
from typing import List, Dict
import re
import json
import requests
import uuid
import mimetypes
import shutil

#需要替换cookie值
cookie = ""
user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36"

default_work_dir = "C:\\Users\\kdyzm\\Documents"
default_charset = "UTF-8"


def choose_markdown_files() -> str:
    # 创建Tkinter根窗口并隐藏
    root = tk.Tk()
    root.withdraw()
    # 配置文件对话框参数
    file_path = filedialog.askopenfilename(
        title="请选择markdown文件",  # 对话框标题
        initialdir=os.path.expanduser(default_work_dir),  # 初始目录为用户主目录
        filetypes=[  # 文件类型过滤
            ("Markdown文件", "*.md")
        ],
        # multiple=True
    )
    # 销毁根窗口
    root.destroy()
    return file_path


def parse_content(content: str) -> List[str]:
    origin_urls: List[str] = re.findall(r"https?://.+\.(?:jpg|png|gif|jpeg)", content, flags=re.IGNORECASE)
    filter_urls = [url for url in origin_urls if "cnblogs.com" not in url]
    return filter_urls


def download_file_to_temp_dir(image_url: str) -> Path:
    """
    下载图片到本地
    :param image_url: 远程url地址
    :return: 下载到本地的绝对路径
    """
    parent_dir = Path("temp")
    if not parent_dir.exists():
        parent_dir.mkdir()
    random_name = uuid.uuid4()
    suffix = image_url.split(".")[-1]
    local_image_path = parent_dir.joinpath(str(random_name).lower() + "." + suffix)
    print(f"正在下载图片：{image_url}")
    with local_image_path.open("wb") as file:
        response = requests.get(image_url)
        file.write(response.content)
    print(f"图片已下载到 {local_image_path.absolute()}")
    return local_image_path


def do_upload_file(image_url: str) -> dict:
    headers = {
        "user-agent": user_agent,
        "cookie": cookie
    }
    local_file = download_file_to_temp_dir(image_url)
    with open(local_file.absolute(), "rb") as f:
        mimetype, encoding = mimetypes.guess_type(local_file.name)
        files = {
            "imageFile": (local_file.name, f, mimetype)
        }
        post_data = {
            "host": "www.cnblogs.com",
            "uploadType": "Paste"
        }
        result = requests.post(
            "https://upload.cnblogs.com/imageuploader/CorsUpload",
            data=post_data,
            files=files,
            headers=headers
        )
        content = result.content.decode(default_charset)
        return json.loads(content)


def upload_file(files: List[str]) -> Dict[str, str]:
    if not files:
        return dict()
    file_map = {file: do_upload_file(file)["message"] for file in files}
    return file_map


def replace_all(path: Path, image_map: dict):
    """
    解析markdown文件并将所有旧文件链接替换为新文件链接
    :param path: markdown文件路径
    :param image_map: 文件map
    :return:
    """
    content = path.read_text(encoding=default_charset)
    for key, value in image_map.items():
        content = content.replace(key, value)
    path.write_text(content, encoding=default_charset)


def clean_temp_file():
    path = Path("temp")
    if path.is_file():
        path.unlink()  # 删除文件
    elif path.is_dir():
        # 删除非空目录需要递归删除
        shutil.rmtree(path)
    else:
        print("路径不存在或无效")


def open_file(path: Path):
    os.startfile(path.absolute())


def process():
    file_path = choose_markdown_files()
    # 处理用户选择结果
    if not file_path:
        print("用户取消选择")
        return
    path = Path(file_path)
    content = path.read_text(encoding=default_charset)
    origin_urls = parse_content(content)
    print("解析markdown文件获取到如下图片列表:")
    print(f"{json.dumps(origin_urls, indent=4)}")
    if not origin_urls:
        print("未解析到符合条件的图片链接，即将退出程序")
        return
    image_map = upload_file(origin_urls)
    print("获取到旧文件和新文件的字典：")
    print(json.dumps(image_map, indent=4))
    replace_all(path, image_map)
    print("替换文件完成")
    print("开始清理暂存文件")
    clean_temp_file()
    print("暂存文件清理完成")
    print("即将打开目标文件")
    open_file(path)


if __name__ == '__main__':
    input("使用须知：使用此脚本必须修改脚本cookie字段，若已知晓，回车继续：")
    process()

运行这个脚本前，需要先修改代码中的cookie值：登录博客园后，从浏览器中复制。

二、运行界面

脚本运行时会在脚本所在目录创建一个temp文件夹，用于暂时存放下载的图片，脚本运行结束会自动删除该文件夹。

END.

大模型开发之langchain0.3（三）：方法调用

Tue, 01 Apr 2025 17:58:48 +0800

我们思考一个问题：大语言模型是否能帮我们做更多的事情，比如帮我们发送邮件。默认情况下让大模型帮我们发送邮件，大模型会这样回复我们：

可以看到，大模型无法发送邮件，它只会帮我们生成一个邮件模板，然后让我们自己手动发送出去。如何让大模型拥有发送邮件的能力呢？这里就引入来了一个概念：function calling。

一、概念：Function calling

简单来说，Function calling让大语言模型拥有了调用外部接口的能力，使用这种能力，大模型能做一些比如实时获取天气信息、发送邮件等和现实世界交互的事情。

1、原理

在发送信息给大模型的时候，携带着“工具”列表，这些工具列表代表着大模型能使用的工具。当大模型遇到用户提出的问题时，会先思考是否应该调用工具解决问题，如果需要调用工具，和普通消息不同，这种情况下会返回“function_call”类型的消息，请求方根据返回结果调用对应的工具得到工具输出，然后将之前的信息加上工具输出的信息一起发送给大模型，让大模型整合起来综合判断给出结果。

以获取天气信息为例，官网给出了获取天气的流程图

2、案例

OpenAI官网Function calling文档：https://platform.openai.com/docs/guides/function-calling?api-mode=responses&example=get-weather

文档中给了获取天气、发送邮件、搜索本地知识库这三个例子，以获取天气为例：

from openai import OpenAI

client = OpenAI()

tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current temperature for a given location.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City and country e.g. Bogotá, Colombia"
            }
        },
        "required": [
            "location"
        ],
        "additionalProperties": False
    }
}]

response = client.responses.create(
    model="gpt-4o",
    input=[{"role": "user", "content": "What is the weather like in Paris today?"}],
    tools=tools
)

print(response.output)

结果输出：

[{
    "type": "function_call",
    "id": "fc_12345xyz",
    "call_id": "call_12345xyz",
    "name": "get_weather",
    "arguments": "{\"location\":\"Paris, France\"}"
}]

可以看到，使用OpenAI的官方API调用很繁琐，而且定义工具列表需要使用json格式的字符串，非常的不友好，lagnchain则解决了这些麻烦。

二、langchain中的Tool calling

langchain中的Function calling换了个更直接的名字：Tool calling，翻译过来叫做“工具调用”，实际上底层还是使用的Function calling。

Tools概念：https://python.langchain.com/docs/concepts/tools/

Tool calling概念：https://python.langchain.com/docs/concepts/tool_calling/

1、工具定义

定义工具很简单，使用装饰器@tool，比如定义两数相乘的工具如下：

from langchain_core.tools import tool

@tool
def multiply(a: int, b: int) -> int:
   """Multiply two numbers."""
   return a * b

可以看到，定义一个工具方法很简单，普通方法加上装饰器@tool即可（关于复杂方法后续再讲）。

工具定义完成，可以使用

print(
    json.dumps(
        multiply.args_schema.model_json_schema(),
        indent=4,
        ensure_ascii=False,
    )
)

打印scheme信息：

{
    "description": "Multiply two numbers.",
    "properties": {
        "a": {
            "title": "A",
            "type": "integer"
        },
        "b": {
            "title": "B",
            "type": "integer"
        }
    },
    "required": [
        "a",
        "b"
    ],
    "title": "multiply",
    "type": "object"
}

2、工具调用

上面我们已经定义好了两数相乘的工具：

from langchain_core.tools import tool

@tool
def multiply(a: int, b: int) -> int:
   """Multiply two numbers."""
   return a * b

接下来使用携带该工具访问大模型：

# Tool 创建
tools = [multiply]
# Tool 绑定
model_with_tools = model.bind_tools(tools)
# Tool 调用 
response = model_with_tools.invoke("2乘以2等于多少？")

输出大模型返回的function_tool信息：

print(json.dumps(response.tool_calls, indent=4))

结果如下所示：

[
    {
        "name": "multiply",
        "args": {
            "a": 2,
            "b": 3
        },
        "id": "chatcmpl-tool-83c83e9537ae4820bc3b1123fec3570b",
        "type": "tool_call"
    }
]

它告诉我们要调用multiply方法，参数是a=2和b=3，如何调用呢？

3、工具执行

大模型已经告诉我们要执行的方法以及调用的参数了，接下来如何执行呢？

第一步：转换tool列表为字典

tool_dic = {tool.name: tool for tool in tools}

第二步：依次执行tool_call列表中的方法

for tool_call in response.tool_calls:
    selected_tool = tool_dic[tool_call["name"].lower()]
    tool_msg = selected_tool.invoke(tool_call)
    print(type(tool_msg))

这样就可以执行目标方法了。注意这里返回的tool_msg信息类型是ToolMessage。

接下来需要将上下文信息带着最后输出的工具输出的信息一起打包给大模型，让大模型整合结果输出给出最终答案。

4、整合到大模型

调用完工具之后需要将结果告诉大模型，让大模型综合上下文得到后续答案。如何告诉大模型呢？在上一篇文章《大模型开发之langchain0.3（二）：构建带有记忆功能的聊天机器人》中告诉大模型上下文，也即是历史记录的方法就是构造Message列表，上一步工具执行的结果返回类型是ToolMessage，我们将它加入列表即可；最后将message列表一起发送给大模型，让大模型给出答案。

完整代码如下所示：

from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool


@tool
def multiply(a: int, b: int) -> int:
    """Multiply a and b."""
    print("multiply 方法被执行")
    return a * b


model = init_chat_model("gpt-3.5-turbo")
# Tool 创建
tools = [multiply]
# Tool 绑定
model_with_tools = model.bind_tools(tools)
# Tool 调用
history = [HumanMessage("2乘以3等于多少？")]
ai_message = model_with_tools.invoke(history)
history.append(ai_message)
tool_dic = {tool.name: tool for tool in tools}
for tool_call in ai_message.tool_calls:
    selected_tool = tool_dic[tool_call["name"].lower()]
    tool_msg = selected_tool.invoke(tool_call)
    history.append(tool_msg)

ai_message = model_with_tools.invoke(history)
print(ai_message.content)
if __name__ == '__main__':
    pass

结果：

multiply 方法被执行
2乘以3等于6。

三、整合gradio

为了更直观的查看工具调用的情况，将本节内容整合到gradio是个不错的选择，同时需要兼容上篇文章《大模型开发之langchain0.3（二）：构建带有记忆功能的聊天机器人》中记忆功能、Context Window限制功能，由于使用了工具调用，暂时没想好如何实现工具调用显示和正文部分流式输出的组合。

1、代码整合

核心点在于如何显示方法调，可以参考文档：https://www.gradio.app/docs/gradio/chatbot#demos 案例中的chatbot_with_tools 章节。

from gradio import ChatMessage
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, AIMessage, trim_messages
from langchain_core.tools import tool
import gradio as gr


@tool
def multiply(a: int, b: int) -> int:
    """Multiply a and b."""
    print("multiply 方法被执行")
    return a * b


model = init_chat_model("gpt-3.5-turbo")
# Tool 创建
tools = [multiply]
# Tool 绑定
model_with_tools = model.bind_tools(tools)

trimmer = trim_messages(
    max_tokens=300,
    strategy="last",
    token_counter=model,
    include_system=True,
    allow_partial=False,
    start_on="human",
)


def response(input_message, gradio_history):
    # Tool 调用
    history = [HumanMessage(i["content"]) if i["role"] == 'user' else AIMessage(i["content"]) for i in gradio_history]
    history.append(HumanMessage(input_message))
    local_gradio_history = list()
    ai_message = model_with_tools.invoke(trimmer.invoke(history))

    if ai_message.tool_calls:
        tool_dic = {tool_item.name: tool_item for tool_item in tools}
        for tool_call in ai_message.tool_calls:
            tool_name = tool_call["name"].lower()
            selected_tool = tool_dic[tool_name]
            tool_msg = selected_tool.invoke(tool_call)
            history.append(tool_msg)
            local_gradio_history.append(
                ChatMessage(
                    role="assistant",
                    content=f"tool '{tool_name}' invoke result is {tool_msg}",
                    metadata={"title": f"️ Used tool '{tool_name}'"},
                )
            )
            yield local_gradio_history
            ai_message = model_with_tools.invoke(trimmer.invoke(history))

    local_gradio_history.append(
        ChatMessage(
            role="assistant",
            content=ai_message.content,
        )
    )
    yield local_gradio_history


demo = gr.ChatInterface(
    fn=response,
    type="messages",
    flagging_mode="manual",
    flagging_options=["Like", "Spam", "Inappropriate", "Other"],
    save_history=True,
)

if __name__ == '__main__':
    demo.launch()

2、运行界面

四、注意事项

注意，并非所有的大模型都支持function_call，不支持function_call的大模型输出返回的AIMessage的tool_calls字段一直是空的。

Python脚本：GIF压缩工具

Mon, 31 Mar 2025 17:11:04 +0800

我经常使用ScreenToGif工具生成GIF动图，有的时候GIF生成的比较大，互联网上有很多在线GIF压缩工具，但是有些不能用，有些速度慢。。。有没有本地工具压缩GIF呢？其实是有的，那就是Gifsicle。

一、Gifsicle

Gifsicle是一个命令行工具，能够创建、编辑GIF动图。

官网地址：https://www.lcdf.org/gifsicle/

下载地址：https://eternallybored.org/misc/gifsicle/

完整的使用手册：https://www.lcdf.org/gifsicle/man.html

1、安装

安装比较简单，下载下来之后将命令行工具目录添加到Path就可以了，运行gifsicle --version命令，出现如下界面就表示安装成功了：

2、使用

使用手册上的内容比较多，我们只关心关于能压缩GIF体积的参数。

--optimize：最重要的优化参数，能有效压缩GIF大小，使用方式为-O{level}，level为1、2、3其中一种，数字越大，压缩效果越好，但是耗时也更长，一般想要更好的压缩效果，使用-O3即可。

--colors：减小GIF中使用到的颜色数量到指定数量，通过减小改值，可以有效减小GIF体积。使用方式：--colors={num}，num必须是2到256之间的值。

--lossy：有损度，默认值大小为20，该值越大，生成的GIF体积越小，使用方式：--lossy={num}

这样，如果我们想压缩一张GIF动图，可以使用如下命令：

gifsicle -O3 --lossy=100 --colors=64 input.gif -o output.gif

二、python脚本

为了更方便的使用gifsicle工具，我写了一个python脚本。

需要先安装依赖：pip install tkinter rich

完整代码如下所示：

import sys
import tkinter as tk
from tkinter import filedialog, messagebox
import os
import subprocess
from pathlib import Path
import time
from rich.progress import Progress

"""
这是一个压缩gif图像的python脚本
"""

#默认存放GIF动图的目录，需要修改成自己的
default_work_dir = "E:\\动图"
run_mode = 1


def choose_gif_files():
    # 创建Tkinter根窗口并隐藏
    root = tk.Tk()
    root.withdraw()

    # 配置文件对话框参数
    file_path = filedialog.askopenfilename(
        title="请选择动图文件",  # 对话框标题
        initialdir=os.path.expanduser(default_work_dir),  # 初始目录为用户主目录
        filetypes=[  # 文件类型过滤
            ("动图文件", "*.gif")
        ],
        # multiple=True
    )
    # 销毁根窗口
    root.destroy()
    return file_path


def do_process_file(file):
    path = Path(file)
    parent_path = path.parent
    origin_file_name = path.name
    split_parts = origin_file_name.split(".")
    new_file_path = parent_path.joinpath(f"{split_parts[0]}_resize.{split_parts[1]}")
    lossy = input("--lossy（默认300，越大压缩效果越好）:")
    colors = input("--colors（默认64，越小压缩效果越好，但是图片可能会失真）:")
    print(f"正在处理文件{file}的转换......")
    result = subprocess.Popen(
        [
            "gifsicle",
            "-O3",
            f"--lossy={300 if not lossy else lossy}",
            f"--colors={64 if not colors else colors}",
            "--no-extensions",
            str(file).replace("/", "\\"),
            "-o",
            new_file_path.absolute()
        ],
        stdout=subprocess.PIPE,
        text=True
    )
    # 逐行读取输出
    while True:
        output = result.stdout.readline()
        if output == "" and result.poll() is not None:
            break
        if output:
            print(output.strip())

    # 获取返回码
    return_code = result.poll()
    if return_code == 0:
        return path, new_file_path
    else:
        return path, None


def open_dir(file_path):
    try:
        subprocess.Popen(f'explorer /select, "{file_path.absolute()}"', shell=True)
    except Exception as e:
        messagebox.showerror("错误", f"无法打开资源管理器：{e}")


def format_size(bytes_num):
    """
    将字节数转换为自适应单位（KB/MB/GB等）
    :param bytes_num: 文件字节数，支持负数
    :return: 带单位的格式化字符串
    """
    units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
    sign = '-' if bytes_num < 0 else ''
    size = abs(bytes_num)
    index = 0

    while size >= 1024 and index < len(units) - 1:
        size /= 1024.0
        index += 1

    return f"{sign}{size:.2f} {units[index]}"


def print_origin_and_new_file_diff_info(origin_file_path: Path, new_file_path: Path):
    origin_file_size = origin_file_path.stat().st_size
    new_file_size = new_file_path.stat().st_size
    print(
        f"源文件大小：{format_size(origin_file_size)}，新文件大小：{format_size(new_file_size)}，"
        f"节约{(((origin_file_size - new_file_size) / origin_file_size) * 100):.2f}%的空间"
    )


def process():
    file_path = choose_gif_files()
    # 处理用户选择结果
    if not file_path:
        print("用户取消选择")
        return
    origin_file_path, new_file_path = do_process_file(file_path)
    if new_file_path:
        print_origin_and_new_file_diff_info(origin_file_path, new_file_path)
        open_result_dir_flag = input(f"转换后文件：{new_file_path.absolute()}，是否打开转换后目标文件夹（y/n）?")
        if open_result_dir_flag == 'n' or open_result_dir_flag == 'N':
            return
        else:
            open_dir(new_file_path)
    else:
        print("转换失败")


def exit_program():
    with Progress() as progress:
        # 创建一个隐藏进度条的任务（总时间为3秒）
        task = progress.add_task(
            description="[bold red]即将退出程序... (5)",  # 初始描述
            total=5,
            visible=True, 
        )

        for remaining in range(5, 0, -1):
            # 更新描述中的倒计时数字
            progress.update(
                task,
                description=f"[bold red]即将退出程序... ({remaining})",
                advance=1,
                refresh=True
            )
            time.sleep(1)  # 等待1秒
    sys.exit(0)


if __name__ == '__main__':
    while True:
        process()
        if run_mode == 1:
            exit_program()
            break
        continue_flag = input("是否继续转换（y/n）?")
        if continue_flag == 'n' or continue_flag == 'N':
            exit_program()
        continue

运行结果如下：

大模型开发之langchain0.3（二）：构建带有记忆功能的聊天机器人

Sat, 29 Mar 2025 09:34:50 +0800

在上一篇文章《大模型开发之langchain0.3（一）：入门篇》中已经介绍了langchain开发框架的搭建，最后使用langchain实现了HelloWorld的代码案例，本篇文章将从0到1搭建带有记忆功能的聊天机器人。

一、gradio

我们可以使用gradio“画”出类似于chatgpt官网的聊天界面，gradio的特点就是“快”，不用考虑html怎么写，css样式怎么写，该怎样处理按钮的响应。。这一切都被gradio处理完了，我们只需要使用即可。

gradio官网：https://www.gradio.app/

官网首页上列举了几种典型的gradio使用场景，其中一种正是我们想要的chatbot的使用场景：

找到左下方对应的源码链接，复制到我们的项目：

import time
import gradio as gr

# 生成器函数，用于模拟流式输出
def slow_echo(message, history):
    for i in range(len(message)):
        time.sleep(0.05)
        yield "You typed: " + message[: i + 1]

demo = gr.ChatInterface(
    slow_echo,
    type="messages",
    flagging_mode="manual",
    flagging_options=["Like", "Spam", "Inappropriate", "Other"],
    save_history=True,
)

if __name__ == "__main__":
    demo.launch()

我们安装好最新版本的gradio就可以成功运行以上代码了：

pip install gradio==5.23.1

二、聊天机器人实现

根据上一节内容，将大模型的输出给到gradio即可，完整实现代码如下：

import gradio as gr

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4o", model_provider="openai")


def do_response(message, history):
    resp = model.invoke(message)
    return resp.content


demo = gr.ChatInterface(
    do_response,
    type="messages",
    flagging_mode="manual",
    flagging_options=["Like", "Spam", "Inappropriate", "Other"],
    save_history=True,
)

if __name__ == "__main__":
    demo.launch()

代码运行结果如下所示：

可以看到，响应时间比较长，足足有十秒钟，在这期间看不到中间的过程，只在最后一次性输出了最终内容，对于用户来说很不友好。

接下来将它改造成流式输出。

优化一：流式输出

想要改造流式输出，首先得大模型支持流式输出，再者改造gradio，让它支持流式输出显示。

关于模型的流式输出文档：https://python.langchain.com/docs/how_to/streaming_llm/

关于gradio的流式输出显示文档：https://www.gradio.app/guides/creating-a-chatbot-fast#streaming-chatbots

简单来说，gradio的流式输出很简单，将do_response方法改造成生成器函数即可

import time
import gradio as gr

def slow_echo(message, history):
    for i in range(len(message)):
        time.sleep(0.3)
        yield "You typed: " + message[: i+1]

gr.ChatInterface(
    fn=slow_echo, 
    type="messages"
).launch()

而stream方法支持流式输出，使用示例如下所示：

from langchain_openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0, max_tokens=512)
for chunk in llm.stream("Write me a 1 verse song about sparkling water."):
    print(chunk, end="|", flush=True)

两者结合起来，改造后的流式输出代码如下所示：

import gradio as gr

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4o", model_provider="openai")


def response(message, history):
    resp = ""
    for chunk in model.stream(message):
        resp = resp + chunk.content
        yield resp


demo = gr.ChatInterface(
    fn=response,
    type="messages",
    flagging_mode="manual",
    flagging_options=["Like", "Spam", "Inappropriate", "Other"],
    save_history=True,
)

if __name__ == '__main__':
    demo.launch()

运行结果：

这样就实现了流式输出。

但是这个程序还有问题：它没有记忆功能，如下所示

接下来对它继续优化，加上记忆功能

优化二：上下文记忆功能

在改造之前，需要先了解几个概念：Chat history、Messages

大模型之所以有记忆功能，是因为每次和大模型对话，都会将历史记录一起送给大模型。

和大模型的交互的过程中，最常见的有三种消息类型：System Message、Human Message、AI Message。

消息类型	释义
System Message	就是开始对话之前对大模型的引导信息，比如“你是一个智能助手，回答用户信息请使用中文”，这样让大模型“扮演”某种角色。
Human Message	我们提出的问题
AI Message	大模型响应的问题。

这三种消息被langchain封装成了不同的类以方便使用：SystemMessage、HumanMessage、AIMessage

那如何将对话历史记录告诉大模型呢？

答案在于model.stream方法，stream默认我们只传输了一个字符串，也就是用户的提问消息，实际上它的类型是LanguageModelInput

LanguageModelInput的定义如下

Union的意思就是“选择其中之一”的意思，也就是说LanguageModelInput可以是PromptValue、字符串，或者Sequence[MessageLikeRepresentation]任意之一，关键点就在于Sequence[MessageLikeRepresentation]，从字面意思上来看它是一个列表类的对象，MessageLikeRepresentation的定义如下，它支持BaseMessage类型

也就是说，可以传递一个BaseMessage类型的List给stream方法，而SystemMessage、HumanMessage、AIMessage 均是BaseMessage的子类。。。一切清晰明了了，可以用一行代码实现gradio历史记录到BaseMessage列表的转换：

h = [HumanMessage(i["content"]) if i["role"] == 'user' else AIMessage(i["content"]) for i in history]

优化后的完整代码如下所示：

import gradio as gr
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, AIMessage

model = init_chat_model("gpt-4o", model_provider="openai")


def response(message, history):
    h = [HumanMessage(i["content"]) if i["role"] == 'user' else AIMessage(i["content"]) for i in history]
    h.append(HumanMessage(message))
    resp = ""
    for chunk in model.stream(h):
        resp = resp + chunk.content
        yield resp


demo = gr.ChatInterface(
    fn=response,
    type="messages",
    flagging_mode="manual",
    flagging_options=["Like", "Spam", "Inappropriate", "Other"],
    save_history=True,
)

if __name__ == '__main__':
    demo.launch()

运行结果如下：

好了，到此，我们用了不到30行代码实现了一个基本的智能聊天机器人，这个程序还有什么问题需要注意的吗？我们思考一下，每次和大模型交互，都要将所有历史记录传递给大模型，这行的通吗？实际上每种大模型都有输入长度的限制，如果不加以限制的话，会很容易超出大模型能够输入字符的上限，接下来改造下这段代码，限制输入的字符数量。

优化三：限制输入长度

关于输入长度过长的优化，实际上是一个比较复杂的问题，可以参考以下官方文档：

Context Window的概念：https://python.langchain.com/docs/concepts/chat_models/#context-window

Memory的概念：https://langchain-ai.github.io/langgraph/concepts/memory/

trim_message的详细用法：https://python.langchain.com/docs/how_to/trim_messages/

trim_message在chatbot中的应用案例：https://python.langchain.com/docs/tutorials/chatbot/#managing-conversation-history

总结一下，用户能输入的字符长度实际上是大模型能“记住”的文本长度，如果过长，就会达到"Context Window"的极限，大模型要么删除一部分文本继续处理，要么直接抛出异常，前者会导致处理数据结果不准确，后者则会导致应用程序直接报错。

可以使用trim_message方法解决该问题，它有各种策略截取过长的输入文本，甚至可以自定义策略。比如以下使用方式：

from langchain_core.messages import trim_messages

trimmer = trim_messages(
    max_tokens=300,
    strategy="last",
    token_counter=model,
    include_system=True,
    allow_partial=False,
    start_on="human",
)

该案例中制定的策略是只允许输入最大300个字符，超出的字符从尾部向前查找删除，而且不允许对消息部分删除（保留问题完整性）。

完整代码如下所示：

from langchain.chat_models import init_chat_model
import gradio as gr
from langchain_core.messages import HumanMessage, AIMessage, trim_messages

model = init_chat_model("gpt-4o", model_provider="openai")

trimmer = trim_messages(
    max_tokens=300,
    strategy="last",
    token_counter=model,
    include_system=True,
    allow_partial=False,
    start_on="human",
)


def response(message, history):
    h = [HumanMessage(i["content"]) if i["role"] == 'user' else AIMessage(i["content"]) for i in history]
    h.append(HumanMessage(message))
    result = trimmer.invoke(h)
    //查看trim结果
    print(result)
    resp = ""
    for chunk in model.stream(result):
        resp = resp + chunk.content
        yield resp


demo = gr.ChatInterface(
    fn=response,
    type="messages",
    flagging_mode="manual",
    flagging_options=["Like", "Spam", "Inappropriate", "Other"],
    save_history=True,
)

if __name__ == '__main__':
    demo.launch()

运行结果如下：

后台打印的被优化的消息：

[HumanMessage(content='你好，我的名字叫kdyzm', additional_kwargs={}, response_metadata={})]
[HumanMessage(content='你好，我的名字叫kdyzm', additional_kwargs={}, response_metadata={}), AIMessage(content='你好，kdyzm！很高兴认识你。有什么我可以帮忙的吗？', additional_kwargs={}, response_metadata={}), HumanMessage(content='帮我写一段python版本的快速排序算法，并分析', additional_kwargs={}, response_metadata={})]
[HumanMessage(content='我是谁？', additional_kwargs={}, response_metadata={})]

可以看到，第三次询问的时候，之前的消息就被删除，不再发送给大模型，这导致大模型忘记了我之前告诉它的我的名字。

END.

大模型开发之langchain0.3（一）：入门篇.md

Fri, 28 Mar 2025 13:50:03 +0800

这是一篇langchain0.3框架helloworld级别的入门教程，包含了python版本的选型、包下载以及helloworld代码案例。

一、langchain简介

langchain是一个用于开发由大语言模型（LLM，Large Language Model）驱动的应用程序开发框架，被业界称为大语言模型开发的“瑞士军刀”：langchain有大量的组件（components）以及第三方集成框架，可以快速实现业务功能开发。

需要注意的是，实际上langchain家族有三种框架：langchain、langsmith、langgraph

langchain：langchain的核心就是"chain"，也就是链式调用，还包含了agent、RAG技术等相关的核心API
langsmith：可以用langsmith监控和评估应用程序，观察应用程序运行的细节。
langgraph：它是一种编排框架，其核心就是“Agent”，相对于langchain将各种组件编排为一种“流线型”架构，langgraph将各种组件编排为一种图（graph）状架构，能够解决完成更复杂的任务。

二、版本选择

1、langchain版本选择

langchain是一个很新的框架，这两年随着大语言模型的兴起而兴起，版本迭代到现在（2025年3月28日），也才迭代到0.3.21版本，所以既然要学习就学习最新的，可以到 https://pypi.org/ 网站查看该包的发布情况

2、python版本选择

python版本应当适配选择的langchain版本，点击上图中的0.3.21版本详情页，在左下角可以看到对python版本的要求

python版本应当大于等于3.9，我这里选择了3.11.11，为什么选择这个版本呢？因为另外一个组件langgraph，在其文档中说明了使用3.11版本最适合

https://academy.langchain.com/courses/take/intro-to-langgraph/texts/58238105-getting-set-up

最后，要使用conda新建python运行环境，防止学习的过程中把环境搞乱了，conda的安装和使用可以参考：python版本管理神器：conda

三、Hello，World！

为了能够通过代码调用OpenAI服务，需要申请OpenAI的秘钥key。当然像是国内开源的大模型基本上也都兼容OpenAI的接口形式，所以也可以申请国内大模型的ApiKey替代，代码中可以显示指定使用的Key，但是每次指定都不方便，还容易泄露key，所以一般是使用环境变量的方式指定key。

1、环境变量设置

设置环境变量：

变量名	变量值
`OPENAI_API_BASE`	默认的OpenAI的值是`https://api.openai.com`，国内的比如硅基流动则是`https://api.siliconflow.cn`，其它的服务提供商有可能带有`/v1`后缀，如果代码运行报错，可以尝试加上`/v1`后缀试试。
`OPENAI_API_KEY`	申请的秘钥。

设置完成环境变量后，可以在命令行中查看是否设置生效：

echo %OPENAI_API_BASE%

或者可以通过set命令查看所有的环境变量列表。

需要注意的是，如果修改了环境变量的值，webstorm的命令行有可能有缓存导致报错，这时候需要重启webstorm就可以解决缓存问题，如果不行，就反复重启几次。

2、安装依赖

假设读者已经使用conda创建了新的python开发环境langchain0.3.21，并且应用到了webstorm，则在webstorm的终端环境输出python --version，则有如下显示

接下来在终端中运行命令：

pip install langchain[openai]==0.3.21

安装相关依赖（可能由于网络问题会比较慢，读者自行解决）

3、Hello，World！

新建一个Python文件，运行如下代码

import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
    os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4o", model_provider="openai")

resp = model.invoke("Hello, world!")
print(type(resp))
print(resp.content)

if __name__ == '__main__':
    pass

输出如下所示：

<class 'langchain_core.messages.ai.AIMessage'>
Hello! How can I assist you today?

这样，一个HelloWorld级别的代码示例就运行成功了。

END.

Ubuntu+Windows双系统彻底卸载Ubuntu系统的方法

Sun, 23 Mar 2025 21:46:34 +0800

第一步：下载DiskGenius软件

下载地址：https://clamowo.lanzoui.com/b05agns3g

第二步：删除Ubuntu系统分区

第三步：EFI引导删除Ubuntu选项

最后重启电脑即可。

http-server优化默认列表展示

Thu, 06 Mar 2025 11:22:46 +0800

node安装好http-server模块后，通过http-server .命令浏览器默认展示效果如下：

个人觉得挺丑的，忍不了一点，我想改一改其CSS样式，优化下展示效果，但是找了半天网上竟然没有教程。。。。没办法，硬着头皮找了半天代码，终于找到了在哪里修改

第一步：找到http-server安装目录

我使用的nvm管理多个node版本，使用nvm root命令可以看到nvm的安装目录，全局安装的node module都在对应的版本下的node文件夹中。

若是直接安装的node，可以使用命令npm root -g 查看全局package安装的位置。

第二步：修改css样式

打开node_modules\http-server\lib\core\show-dir文件夹，修改styles.js文件，复制如下内容覆盖styles.js文件

'use strict';

const icons = require('./icons.json');

const IMG_SIZE = 16;

let css = `i.icon { display: block; height: ${IMG_SIZE}px; width: ${IMG_SIZE}px; }\n`;
css += 'table tr { white-space: nowrap; line-height: 30px;color:rgb(68, 68, 68);}\n';
css += 'td.perms {}\n';
css += 'td.file-size { text-align: right; padding-left: 1em; }\n';
css += 'td.display-name { padding-left: 1em; }\n';
css += '.displayName{text-decoration: none;cursor: pointer;}';
css += 'a{color:rgb(68, 68, 68);}';
css += 'a:hover{color:black;font-weight:bold;}';

Object.keys(icons).forEach((key) => {
  css += `i.icon-${key} {\n`;
  css += `  background-image: url("data:image/png;base64,${icons[key]}");\n`;
  css += '}\n\n';
});

exports.icons = icons;
exports.css = css;

第三步：修改默认显示模板

打开node_modules\http-server\lib\core\show-dir文件夹，修改index.js文件，复制如下内容覆盖index.js文件

'use strict';

const styles = require('./styles');
const lastModifiedToString = require('./last-modified-to-string');
const permsToString = require('./perms-to-string');
const sizeToString = require('./size-to-string');
const sortFiles = require('./sort-files');
const fs = require('fs');
const path = require('path');
const he = require('he');
const etag = require('../etag');
const url = require('url');
const status = require('../status-handlers');

const supportedIcons = styles.icons;
const css = styles.css;

module.exports = (opts) => {
  // opts are parsed by opts.js, defaults already applied
  const cache = opts.cache;
  const root = path.resolve(opts.root);
  const baseDir = opts.baseDir;
  const humanReadable = opts.humanReadable;
  const hidePermissions = opts.hidePermissions;
  const handleError = opts.handleError;
  const showDotfiles = opts.showDotfiles;
  const si = opts.si;
  const weakEtags = opts.weakEtags;

  return function middleware(req, res, next) {
    // Figure out the path for the file from the given url
    const parsed = url.parse(req.url);
    const pathname = decodeURIComponent(parsed.pathname);
    const dir = path.normalize(
      path.join(
        root,
        path.relative(
          path.join('/', baseDir),
          pathname
        )
      )
    );

    fs.stat(dir, (statErr, stat) => {
      if (statErr) {
        if (handleError) {
          status[500](res, next, { error: statErr });
        } else {
          next();
        }
        return;
      }

      // files are the listing of dir
      fs.readdir(dir, (readErr, _files) => {
        let files = _files;

        if (readErr) {
          if (handleError) {
            status[500](res, next, { error: readErr });
          } else {
            next();
          }
          return;
        }

        // Optionally exclude dotfiles from directory listing.
        if (!showDotfiles) {
          files = files.filter(filename => filename.slice(0, 1) !== '.');
        }

        res.setHeader('content-type', 'text/html');
        res.setHeader('etag', etag(stat, weakEtags));
        res.setHeader('last-modified', (new Date(stat.mtime)).toUTCString());
        res.setHeader('cache-control', cache);
        function render(dirs, renderFiles, lolwuts) {
          // each entry in the array is a [name, stat] tuple

		  var dispayPathname = pathname;
		  if(dispayPathname.length>=3){
			dispayPathname = pathname.substring(1,pathname.length-1)
		  }
          let html = `${[
            '<!doctype html>',
            '<html>',
            '  <head>',
            '    <meta charset="utf-8">',
            '    <meta name="viewport" content="width=device-width">',
            `    <title>${he.encode(dispayPathname)}</title>`,
            `    <style type="text/css">${css}</style>`,
            '  </head>',
            '  <body>',
            `<h1>${he.encode(dispayPathname)}</h1>`,
          ].join('\n')}\n`;

          html += '<table>';

          const failed = false;
          const writeRow = (file) => {
            // render a row given a [name, stat] tuple
            const isDir = file[1].isDirectory && file[1].isDirectory();
            let href = `./${encodeURIComponent(file[0])}`;

            // append trailing slash and query for dir entry
            if (isDir) {
              href += `/${he.encode((parsed.search) ? parsed.search : '')}`;
            }

            const displayName = he.encode(file[0]) + ((isDir) ? '/' : '');
            const ext = file[0].split('.').pop();
            const classForNonDir = supportedIcons[ext] ? ext : '_page';
            const iconClass = `icon-${isDir ? '_blank' : classForNonDir}`;
			
            // TODO: use stylessheets?
            html += `${'<tr class="customTr">' +
              '<td><i class="icon '}${iconClass}"></i></td>`;
            if (!hidePermissions) {
              html += `<td class="perms"><code>(${permsToString(file[1])})</code></td>`;
            }
            html +=
              `<td class="last-modified">${lastModifiedToString(file[1])}</td>` +
              `<td class="file-size"><code>${sizeToString(file[1], humanReadable, si)}</code></td>`;
			  if(isDir){
				html+=`<td class="display-name"><a class="displayName" href="${href}">${displayName}</a></td>`;  
			  }else{
				  var displayName1  = displayName;
				  if(validationEnd(displayName,".html")){
					  displayName1= displayName.substring(0,displayName.length-5);
				  }
				html+=`<td class="display-name"><a class="displayName" href="${href}" target="_blank">${displayName1}</a></td>`;  
			  }
              
              html +='</tr>\n';
          };

          dirs.sort((a, b) => a[0].toString().localeCompare(b[0].toString())).forEach(writeRow);
          renderFiles.sort((a, b) => a.toString().localeCompare(b.toString())*-1).forEach(writeRow);
          lolwuts.sort((a, b) => a[0].toString().localeCompare(b[0].toString())).forEach(writeRow);

          

          if (!failed) {
            res.writeHead(200, { 'Content-Type': 'text/html' });
            res.end(html);
          }
        }

		function validationEnd (str, appoint) {
		   str=str.toLowerCase();  //不区分大小写：全部转为小写后进行判断
				
		   var start = str.length-appoint.length;  //相差长度=字符串长度-特定字符长度
		   var char= str.substr(start,appoint.length);//将相差长度作为开始下标，特定字符长度为截取长度
			
		   if(char== appoint){ //两者相同，则代表验证通过
			  return true;
		   }
		   return false;
		}

        sortFiles(dir, files, (lolwuts, dirs, sortedFiles) => {
          // It's possible to get stat errors for all sorts of reasons here.
          // Unfortunately, our two choices are to either bail completely,
          // or just truck along as though everything's cool. In this case,
          // I decided to just tack them on as "??!?" items along with dirs
          // and files.
          //
          // Whatever.

          // if it makes sense to, add a .. link
          if (path.resolve(dir, '..').slice(0, root.length) === root) {
            fs.stat(path.join(dir, '..'), (err, s) => {
              if (err) {
                if (handleError) {
                  status[500](res, next, { error: err });
                } else {
                  next();
                }
                return;
              }
              dirs.unshift(['..', s]);
              render(dirs, sortedFiles, lolwuts);
            });
          } else {
            render(dirs, sortedFiles, lolwuts);
          }
        });
      });
    });
  };
};

第四步：修改日期展示

打开node_modules\http-server\lib\core\show-dir文件夹，修改last-modified-to-string.js文件，复制如下内容覆盖last-modified-to-string.js文件

'use strict';

Date.prototype.format = function(format)
{
 var o = {
 "M+" : this.getMonth()+1, //month
 "d+" : this.getDate(),    //day
 "h+" : this.getHours(),   //hour
 "m+" : this.getMinutes(), //minute
 "s+" : this.getSeconds(), //second
 "q+" : Math.floor((this.getMonth()+3)/3),  //quarter
 "S" : this.getMilliseconds() //millisecond
 }
 if(/(y+)/.test(format)) format=format.replace(RegExp.$1,
 (this.getFullYear()+"").substr(4 - RegExp.$1.length));
 for(var k in o)if(new RegExp("("+ k +")").test(format))
 format = format.replace(RegExp.$1,
 RegExp.$1.length==1 ? o[k] :
 ("00"+ o[k]).substr((""+ o[k]).length));
 return format;
}

module.exports = function lastModifiedToString(stat) {
  const t = new Date(stat.mtime);
  return t.format('yyyy-MM-dd hh:mm:ss');
};

最后：效果展示

首页：

点击进入子目录：

END.

python脚本：批量修改文件名

Sun, 02 Mar 2025 19:07:17 +0800

该脚本用于Windows系统下批量重命名文件，可以将文件名中的某些字符串删除或者替换为指定字符串。

输入：

目标文件夹：目标文件夹的绝对路径，将会从该文件夹递归查询目标文件
目标文件后缀：查询的文件后缀，比如mp4
待替换字符串：支持正则表达式，注意转义字符，比如：\[.*\]
替换成的字符串：如果为空将会删除待替换的字符串

import re
from pathlib import Path

"""
该脚本用于Windows系统下批量重命名文件，可以将文件名中的某些字符串删除或者替换为指定字符串。

输入：

目标文件夹：目标文件夹的绝对路径，将会从该文件夹递归查询目标文件
目标文件后缀：查询的文件后缀，比如mp4
待替换字符串：支持正则表达式，注意转义字符，比如：\\[.*\\]
替换成的字符串：如果为空将会删除待替换的字符串
"""


def batch_rename_files():
    dir_name = input("请输入目标文件夹：")
    suffix = input("请输入目标文件后缀：")
    replace_str = input("请输入待替换字符串（支持正则表达式）：")
    replaced_str = input("请输入替换成的字符串：（为空表示删除，选填）：")
    pattern = re.compile("^.*(" + replace_str + ").*$")

    if not Path(dir_name).exists():
        raise RuntimeError(f"目标文件不存在：{dir_name}")
    if not Path(dir_name).is_dir():
        raise RuntimeError(f"目标不是文件夹类型：{dir_name}")
    p = Path(dir_name)
    all_files = [i for i in p.glob(f"**/*.{suffix}") if not i.is_dir()]
    for file in all_files:
        file_name = file.name
        if not pattern.match(file_name):
            continue
        result = re.sub(replace_str, lambda x: replaced_str, file_name)
        final_path = file.parent.joinpath(result)
        if final_path == file:
            print(f"skip rename {file} to {final_path} ")
            continue
        print(f"正在重命名 {file} 为 {final_path} ")
        if final_path.exists():
            final_path.unlink()
        file.rename(final_path)
    print("结束执行任务")
    input("输入任意字符继续......")


if __name__ == '__main__':
    while True:
        batch_rename_files()

注意：重命名后的文件如果存在，会先删除旧文件

狂盗一枝梅的博客

解决Windows命令行cmd中文乱码问题

一、乱码现象

二、临时解决方案

三、永久解决方案

记一次Mybatis查询中的数组越界异常

一、问题描述

二、规律总结

三、解决问题

IDEA远程Debug

一、本地IDEA配置

二、远程JVM配置

三、调试

Python脚本：查询占用端口号进程

记一次腾讯云报警 『Lighthouse存在对外攻击的违规通知』

一、排查过程

1、检查弱口令

2、检查恶意进程及非法端口

3、FRP服务端被恶意利用作为攻击跳板的原理

二、解决方案

MySql8.0公共表表达式『CTE』

一、普通CTE

二、递归CTE

1、案例讲解

案例1：打印1到5

案例2：重复字符串

案例3：斐波那契数列

案例4：日期序列生成

案例5：树状组织架构

2、递归失控

3、使用limit终止递归

Redis（十三）：Caffeine+Redis高性能二级缓存实现

一、SpringBoot Caching

1、CacheManager

2、Cache

3、@EnableCaching

二、Caffeine

1、Caffeine的CRUD操作

2、整合Caffeine到SpringBoot

基础使用

配置参数

自定义CaffeineCacheManager

创建独立使用的Caffeine Cache

三、二级缓存架构实现

1、配置文件

2、激活缓存配置

3、业务代码中使用

4、测试二级缓存功能

四、技术细节

1、通过注解隔离三种缓存模式

2、多级缓存的实现

3、缓存一致性

2025新版Maven中央仓库发布jar包教程

摘要

一、将项目推送到远程仓库，如 Github或者Gitee

二、注册 Sonatype 账户

三、登录 Sonatype 创建Namespace

四、发布

1.准备签名

2.settings.xml

3.pom.xml

4.执行命令

5.更新部署

IntelliJ IDEA 2025.2 Maven设置不生效的解决方案

一、问题重现

二、问题分析

三、解决问题

Diskgenius 破解版下载

JetBrains系列软件2025.2版本激活教程

第一步：安装新版本软件

第二步：激活软件

第三步：输入激活码

IDEA 激活码

PyCharm 激活码

DataGrip 激活码

WebStorm 激活码

CLion 激活码

PhpStorm 激活码

GoLand 激活码

Code With Me 激活码

记一次腾讯云报警『Lighthouse存在对外攻击的违规通知』

一、将项目推送到远程仓库，如 `Github`或者`Gitee`

二、注册 `Sonatype` 账户

三、登录 Sonatype 创建`Namespace`