Alignm-ent

AgentSphere 个人项目的分享和理解

2026-07-26T10:24:04.000Z

一、为什么还要造轮子？

2024~2025 被称为 Agent 元年，LangChain、AutoGPT、CrewAI、Dify、Coze……各种框架层出不穷，教程铺天盖地。但真正动手做一个 RAG 知识库 Agent 时，最难的不是”加什么”，而是”不加什么”。

大多数 RAG 方案在做同一件事：把用户问题切碎，和文档的关键词做匹配。但知识不是关键词的集合，知识是关联、是结构、是上下文。

举个例子：一份企业年报写着”A 公司收购了 B 公司”，一份行业研报写着”B 公司的核心技术团队来自 C 实验室”。真正够用的系统，应该能回答”C 实验室的技术最终去了哪里？”——这是一个跨文档推理问题，不是一个关键词匹配问题。

AgentSphere 的核心哲学：不做关键词匹配器，做知识推理器。

二、第一个分岔口：OCR 到底要不要？

大多数 RAG 教程教你用 PyPDFLoader / PyMuPDFLoader 直接读取 PDF。如果是数字原生 PDF，当然没问题。但如果是扫描件——合同、发票、老旧档案——这些工具读出来就是乱码，乱码进向量库，检索质量直接崩。

PaddleOCR 很重——几百 MB 的下载量，推理吃显存。

AgentSphere 的做法：先检查 PDF 是否有可提取的文本层——有就直接解析，跳过 OCR；没有才拉起 PaddleOCR。

核心理念：每个重组件都应该有”跳过”的权利。

三、GraphRAG：最容易被过度工程化的模块

GraphRAG（Microsoft，2024）用知识图谱增强 RAG——把孤立的数据库点连成关系网络，让 AI “理解”数据之间的关联，而不是仅仅检索单个事实。

但三个问题很明显：

实体提取很贵——每个 chunk 一次 LLM 调用，1000 个 chunk = 1000 次 API 调用
图谱质量取决于 LLM 质量——小模型做实体提取，结果一塌糊涂
大部分查询不需要图谱——“这份合同的甲方是谁？”这类简单问题，关键词搜索就能解决

AgentSphere 的设计：GraphRAG 是可选增强，不是默认管线。用一个 Router Agent 做问题分类——事实类查询走 BM25 + 向量检索，关系推理类（”A 和 B 之间有什么关联？”）才触发图谱多跳推理。

GraphRAG 是锤子，但不是所有问题都是钉子。

四、Reranker：最值的 100ms 延迟

混合检索——BM25 关键词 + BGE 向量——之后，RRF 融合出的 Top-10 排序往往有偏差：BM25 偏向给短文本打高分，向量检索偏向长文本。

BGE-Reranker 是 Cross-Encoder，把 query 和 document 拼在一起编码，计算真正的语义匹配。代价：多 100~~200ms 延迟。收益：**Top-5 精度通常提升 15%~~25%**。

如果只选一个优化策略，选 Reranker。

五、Agent 不是越多越好

CrewAI、AutoGen 这些多 Agent 框架给人一种错觉——Agent 越多越智能。

现实是：Agent 的复杂度是指数级的。每多一个 Agent，就多一次 LLM 调用（成本 + 延迟），多一个故障点（A 输出烂 → B 崩 → C 幻觉），调试难度翻倍（到底哪个 Agent 的 prompt 出了问题？）。

AgentSphere 的 5 个 Agent：

Agent	职责	是否必须
Router	问题分类	必须（决定走哪条路）
Planner	执行规划	必须（复杂问题分步编排）
Query Rewrite	查询改写	可选（简单问题跳过）
Answer Verify	事实校验	可选（内部测试时开启）
Orchestrator	协调调度	必须（调度以上所有 Agent）

设计准则：每个 Agent 只做一件事，每个 Agent 都可以被跳过。

六、Token 消耗：你必须关心的事

一次 QA 流程的 Token 消耗示例：

Query Rewrite：500 tokens
实体提取（GraphRAG）：2,000 tokens × 10 chunks = 20,000 tokens
LLM 生成：3,000 tokens
Answer Verify：2,000 tokens
合计：约 25,500 tokens / 次查询

AgentSphere 在代码层面做了 Token 监控——每次 LLM 调用都记入 LLM Monitor，按 Provider 和模型维度分析成本。看不见的成本才是最大的成本。

七、最后的话

AI 肉眼可见地在引领一个新的时代，但创造的本质不是学会调用 API——是形成了一套判断力：

什么时候该上 OCR，什么时候不该
什么时候 GraphRAG 值它的成本，什么时候是过度工程
多一个 Agent 带来的价值，值不值它引入的复杂度
每一行代码是在解决问题，还是在制造问题

AgentSphere 是我个人的学习项目，每个模块都保留了当初决策的分岔口——你完全可以选择另一条路。

希望 AI 不是一个终点，而是形成自己判断的起点。

项目地址：github.com/Alignm-ent/AgentSphere

Python 输入输出与常用标准库使用手册

2026-07-23T07:30:00.000Z

一、输入获取（核心两类场景）

1. 基础 input()

input() 读取一整行，返回字符串，末尾换行自动剔除。

1.1 读取单个数字（数字单独一行）

# 输入每行仅一个数字
a = int(input())
f = float(input())
s = input()  # 读取字符串，原样保留空格

报错场景：一行输入多个数字 2 3，直接 int(input()) 会报错 invalid literal。

1.2 一行多个数字（OJ高频）

# 一行两个整数，空格分隔
a, b = map(int, input().split())

# 一行任意数量数字，存入列表
nums = list(map(int, input().split()))

# 浮点型多数字
x, y = map(float, input().split())

split() 特性：自动按任意空白（空格、Tab、多个连续空格）分割。

1.3 分行读取多组数据

# 读取n行数字
n = int(input())
arr = []
for _ in range(n):
    val = int(input())
    arr.append(val)

2. 高速输入 sys.stdin（大数据量推荐）

数据量大时 input() 速度慢，使用 sys 批量读取。

import sys

# 读取所有输入，按行分割
lines = sys.stdin.readlines()
a = int(lines[0])
b = int(lines[1])

# 一次性读取全部数字（无视换行/空格）
data = list(map(int, sys.stdin.read().split()))
a = data[0]
b = data[1]

3. 输入格式冲突报错说明

代码写法	要求输入格式	错误输入	报错信息
`a=int(input())`	一数一行	`2 3`	`ValueError: invalid literal for int()`
`a,b=map(int,input().split())`	一行两个数	仅输入1个数	`ValueError: not enough values to unpack`

二、输出 print 用法

2.1 基础打印

print("Hello")
print(123)
# 多参数自动空格分隔
print(a, b, "result")
# 不自动换行
print("NO", end="")
# 自定义分隔符
print(1,2,3, sep=",") # 1,2,3

2.2 格式化输出

# f-string（推荐，Python3.6+）
x = 10
print(f"数字是{x}")

# format 兼容旧版本
print("数字是{}".format(x))

# 保留小数
pi = 3.14159
print(f"{pi:.2f}") # 保留2位小数

2.3 批量输出（大数据）

多次 print 效率低，拼接字符串一次性输出：

res = []
res.append("YES")
res.append(str(123))
print('\n'.join(res))

三、Python 容器（对标 C++ STL）

1. list 数组 / vector

对应C++ vector，可变、有序、可重复。

# 初始化
arr = []
arr = [1,2,3]
arr = [0]*10 # 长度10，全0

# 增删改查
arr.append(4)       # 尾部添加 push_back
arr.pop()            # 删除尾部 pop_back
arr.pop(0)           # 删除头部（效率低）
arr.insert(1, 99)   # 指定位置插入
arr.remove(2)        # 删除第一个值为2的元素
print(arr[0])        # 下标访问
print(len(arr))      # size()

2. deque 双端队列（queue / deque STL）

需导入 collections，首尾增删O(1)，替代list做队列。

from collections import deque
q = deque()

q.append(1)    # 队尾入队 push_back
q.appendleft(2)# 队头入队 push_front
q.popleft()    # 队头出队 pop_front
q.pop()         # 队尾出队 pop_back
print(q[0])     # 取队首 front()
print(len(q))   # size()

3. set 集合（std::unordered_set / set）

元素唯一、无序，去重、查找O(1)。

s = set()
s.add(1)       # insert
s.add(1)       # 重复添加自动忽略
s.remove(1)    # 删除元素
print(1 in s)  # 查询是否存在 count()
print(len(s))  # size()

4. dict 字典（std::unordered_map / map）

键值对存储，key唯一，哈希查找。

mp = {}
mp["a"] = 10    # map[key] = val
mp[5] = 20

print("a" in mp) # 判断key是否存在
print(mp.get("b", 0)) # 不存在返回默认值0
del mp["a"]       # 删除键值对
print(len(mp))    # size()

# 遍历键、值
for k in mp:
    print(k, mp[k])

5. tuple 元组

不可变数组，对应const vector，不能增删改。

1
2
3

t = (1,2,3)
print(t[0])
# t[0] = 99 报错，无法修改

容器功能对标简表

Python容器	C++ STL	核心特性
list	vector	可变有序数组，尾部操作快
deque	deque / queue	双端快速增删，适合队列BFS
set	unordered_set	自动去重，快速查找
dict	unordered_map	key-value哈希映射
tuple	const vector	只读固定长度数组

四、通用刷题模板（OJ专用，带Main类避免判题报错）

# -*- coding: utf-8 -*-
from collections import deque

class Main:
    def main(self):
        # 输入1：一行两个数字
        a, b = map(int, input().split())
        # 输入2：数字分行读取
        # a = int(input())
        # b = int(input())
        
        # 逻辑处理示例
        a %= 2
        b %= 2
        if a == 1 or b == 1:
            print("NO")
        else:
            print("YES")

if __name__ == "__main__":
    Main().main()

五、补充注意事项

编码声明：代码含中文注释时，首行添加 # -*- coding: utf-8 -*-，消除 Non-ASCII 报错；
输入格式严格匹配：判题系统输入固定，分行输入不能用 split()，单行多数字不能分次 input()；
容器选择：BFS广度优先搜索优先用 deque，不要用 list 频繁 pop(0)（时间复杂度高）；
大数据优化：数据量上万时，使用 sys.stdin.read() 一次性读取全部输入，减少IO耗时。

Go 语言笔记 & GORM 入门

2025-03-24T01:57:00.000Z

Go 基础语法

导入原则

1	import "xxx"

导入的包或定义的变量若未使用会编译报错——强制减少无用开销。

类型转换

1 2	// 使用 strconv 包进行类型转换 // 函数通常返回两个值：结果值和 error

goto

跳转关键字，可在函数内跳转到指定标签。

函数

Go 中不支持函数重载——同一作用域下函数名必须唯一。

// 别名 ≠ 原类型，不能直接赋值，但可以显式转换后赋值
type MyInt int
var a MyInt = 10
var b int = int(a) // 需要显式转换

包

方法能否被外部调用取决于首字母是否大写（public / private 的体现）
同一个包下不能有重名函数
Go 有”声明必使用”的原则，别名声明后就不能再用原名调用

init() 函数

源文件执行顺序：

1	import → 全局变量定义 → init() → main()

匿名函数

// 一次使用
func() { ... }()

// 多次使用
fn := func() { ... }
fn()

// 全局（可外部引用）
var Fn = func() { ... }

闭包

闭包引用了函数体之外的变量，函数+引用环境 = 闭包。

defer

defer 压栈时相当于值拷贝，不会随后面变化而变化
通常用于资源关闭（文件、连接等），创建资源后紧随 defer 关闭

1 2	f, _ := os.Open("file.txt") defer f.Close()

字符串

1 2	// Go 中一个汉字占 3 字节（UTF-8） // 字符串遍历使用 strings 包

日期时间

import "time"

now := time.Now()
now.Year()
now.Month()
now.Day()

// 时间格式化（数字固定）
now.Format("2006-01-02 15:04:05")

注意：Go 的时间格式化模板数字 2006-01-02 15:04:05 是固定的，不能随意更改。

错误捕获

// defer + recover 替代 try/catch
defer func() {
    if err := recover(); err != nil {
        fmt.Println("捕获异常:", err)
    }
}()

Go 中空值写作 nil，而非 null。

遍历

// for range
for k, v := range 数组名 {
    // k 为下标，v 为对应值
}

GORM 入门

依赖管理

1
2
3

go get          # 下载并安装包
go mod tidy     # 整理依赖，移除未使用的包
go mod vendor   # 生成本地 vendor 目录

DSN 数据库连接

1	// 用户名:密码@tcp(IP)/数据库名?charset=utf8mb4&parseTime=true&loc=Local

&parseTime=true 中的 & 会影响结构体是否同步更新。加 & 时，插入记录后 user.ID 能获取到自增主键值；不加则不会同步，需要手动查询。

常用方法

方法	说明
`Create(&user)`	创建记录
`Save(&user)`	保存或更新，支持事务回滚等校验
`First(&user)`	查询第一条记录（按主键升序）
`Last(&user)`	查询最后一条记录（按主键降序）
`Find(&users)`	查询多条记录
`Where(...).Find(&users)`	条件查询
`Model(&User{}).Update(...)`	更新字段

示例：

1
2
3

db.Where("name = ?", "Alice").Find(&users)
db.Where("id > ?", 20).Find(&users)
db.Model(&User{}).Update("name", "NewName")

模型示例

package models

import (
    "gorm.io/gorm"
    "time"
)

type UserBasic struct {
    gorm.Model
    Username      string
    Password      string
    Phone         string
    Email         string
    Identity      string
    ClientIp      string
    ClientPort    string
    LoginTime     time.Time
    HeartbeatTime time.Time
    LoginOutTime  time.Time `gorm:"column:login_out_time" json:"login_out_time"`
    IsLogout      bool
    DeviceInfo    string
}

func (table *UserBasic) TableName() string {
    return "user_basic"
}

func GetUserList() []*UserBasic {
    data := make([]*UserBasic, 10)
    utils.DB.Find(&data)
    return data
}

Java 接入 AI 接口

2025-02-26T09:49:06.000Z

背景

如果你的项目使用 JDK 17+，推荐学习 Spring AI 框架。本篇以 JDK 8 项目为例，手搓 AI 接口的接入。

依赖引入


<dependency>
    <groupId>com.google.code.gsongroupId>
    <artifactId>gsonartifactId>
    <version>2.8.9version>
dependency>

<dependency>
    <groupId>org.apache.httpcomponents.client5groupId>
    <artifactId>httpclient5artifactId>
    <version>5.1.3version>
dependency>

AI 配置类

建议单独开一个配置类，后续可通过 Nacos 等方式动态更新：

public class AIConfig {
    private String apiKey;
    private String model;
    private String URL;
    private Double temperature;

    public AIConfig() {
        URL = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";
        apiKey = "sk-xxx";
        model = "qwen-plus";
        temperature = 0.8;
    }
}

实体类

public class AIMessage {
    private String role;    // system / user
    private String content;
}

public class AIRequst {
    private String model;
    private List messages;
    private double temperature;
}

核心调用实现

public ResultBody AIImport(String userId, String issue) {
    String key = "AI_" + userId;
    Object cacheObject = redisService.getCacheObject(key);
    String contextInfo = (cacheObject != null) ? (String) cacheObject : "";

    AIRequst openaiReq = new AIRequst();
    openaiReq.setModel(aiConfig.getModel());

    List messages = new ArrayList<>();
    AIMessage systemMessage = new AIMessage();
    systemMessage.setRole("system");
    systemMessage.setContent("你是一个语音聊天助手，会讲冷笑话、鬼故事等。");
    messages.add(systemMessage);

    AIMessage userMessage = new AIMessage();
    userMessage.setRole("user");
    userMessage.setContent(String.format("上下文信息：\n%s\n\n用户问题：%s", contextInfo, issue));
    messages.add(userMessage);

    openaiReq.setMessages(messages);
    openaiReq.setTemperature(aiConfig.getTemperature());

    Gson gson = new Gson();
    String jsonRequest = gson.toJson(openaiReq);

    try {
        URL url = new URL(aiConfig.getURL());
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setRequestProperty("Authorization", "Bearer " + aiConfig.getApiKey());
        connection.setDoOutput(true);

        try (OutputStream os = connection.getOutputStream()) {
            byte[] input = jsonRequest.getBytes(StandardCharsets.UTF_8);
            os.write(input, 0, input.length);
        }

        int responseCode = connection.getResponseCode();
        if (responseCode == 200) {
            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
                StringBuilder response = new StringBuilder();
                String responseLine;
                while ((responseLine = br.readLine()) != null) {
                    response.append(responseLine.trim());
                }

                JsonObject jsonResponse = gson.fromJson(response.toString(), JsonObject.class);
                if (jsonResponse.getAsJsonArray("choices").isEmpty()) {
                    return ResultBody.error().message("AI 响应超时...");
                }

                JsonObject choice = jsonResponse.getAsJsonArray("choices").get(0).getAsJsonObject();
                JsonObject message = choice.getAsJsonObject("message");
                String answer = message.get("content").getAsString().trim();

                if (answer.isEmpty()) {
                    return ResultBody.error().message("AI 响应超时");
                }

                redisService.setCacheObject(key, issue, 300L, TimeUnit.MINUTES);
                return ResultBody.ok().message(answer);
            }
        } else {
            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8))) {
                StringBuilder errorResponse = new StringBuilder();
                String errorLine;
                while ((errorLine = br.readLine()) != null) {
                    errorResponse.append(errorLine.trim());
                }
                System.err.println("错误响应: " + errorResponse);
            }
            return ResultBody.error().message("AI 响应超时...");
        }
    } catch (IOException e) {
        e.printStackTrace();
        return ResultBody.error().message("AI 响应超时");
    }
}

小结

JDK 8 项目可通过 HttpURLConnection 手搓 AI 接口，不需要额外框架
注意提取 AI 配置为独立配置类，方便后续热更新
结合 Redis 缓存上下文信息，实现简单的对话记忆

参考：CSDN - Java接入AI接口

P1113 杂物

2025-02-23T05:52:00.000Z

考点

拓扑排序、图论、递推 / 记忆化搜索。

思路分析

题目给定 n 个任务，每个任务有完成耗时和前置任务。完成所有任务的最短时间，就是从起点到终点的最长路径（因为耗时最长的链决定了整体完成时间）。

本题用 DAG 建图 + 记忆化 DFS 解决：

对每个任务，记录它的前序任务（即谁指向它）
用 DFS 从每个节点出发，递归计算到达该节点的最长路径
记忆化搜索避免重复计算

代码实现

static int dfs(int x) {
    if (f[x] != 0) return f[x];
    for (int i = 0; i < edge[x].size(); i++)
        f[x] = Math.max(f[x], dfs(edge[x].get(i)));
    f[x] += a[x];
    return f[x];
}

// 建图时注意: edge[y].add(x) 表示 y 是 x 的前序

小结

“完成所有任务的最短时间” 在 DAG 中 = 最长路径
记忆化搜索是 DAG 上 DP 的常用实现方式
建图时注意边的方向：前序指向后续

Nginx 相关的经历

2025-02-19T12:03:09.000Z

背景

前后端分离的趋势下，Nginx 已经成为后端开发必须了解的技术点之一。

常用命令

修改或查看 Nginx 配置时，推荐先用 nginx -t 检测配置文件语法，同时它会输出配置文件路径：

# Linux
sudo nginx -t 2>&1 | grep "file"

# Windows
nginx -t 2>&1 | findstr "file"

2>&1 的作用是把标准错误（stderr）重定向到标准输出（stdout），因为 nginx -t 的提示信息通常走 stderr 输出。

反向代理配置写法

server {
    listen 80;
    server_name yourdomain.com;

    location /api {
        proxy_pass http://localhost:8080;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

关键说明：

字段	作用
`listen`	监听的端口
`location /api`	路径匹配，`/` 匹配所有路径；多个服务可细化路径区分
`proxy_pass`	转发的目标地址
`X-Real-IP`	传递客户端真实 IP（否则后端看到的是代理 IP）
`X-Forwarded-For`	记录客户端及中间代理的 IP 链
`X-Forwarded-Proto`	传递原始请求协议（HTTP / HTTPS）

小结

修改配置前先用 nginx -t 检查语法和定位文件
反向代理记得配置请求头透传客户端真实信息
多个服务可通过细化 location 路径做路由分发

参考：CSDN - nginx相关的经历

行锁和表锁

2024-12-17T06:21:54.000Z

背景

后端开发中经常和数据库打交道，查询速率和耗时一直是需要关注的点。行锁和表锁是其中重要的知识点，而理解它们又绕不开索引。

索引为什么能提升查询速度

以 InnoDB 的 B+ 树索引为例。假设有一个数值类型的 id 字段，有 1, 3, 4, 5 四条记录：

无索引：数据按顺序排列，查询需要逐条遍历，时间复杂度 O(n)
有索引：B+ 树结构类似平衡二叉树（左小右大），查询时间复杂度 O(log n)

这就是加索引能大幅提升查询速率的核心原因。

行锁与表锁

有了索引的基础，再看锁就清晰了：

行锁：基于索引字段的增删改语句，会锁定对应的索引行。其他事务可以操作表中其他索引行的数据，并发度高
表锁：不基于索引字段的 SQL（如全表扫描），会锁住整张表，其他 SQL 需要等待，效率低

所以在写业务 SQL 时，尽量基于索引字段操作，既能提升查询效率，又能利用行锁减少锁冲突。

小结

索引是行锁的前提，没有索引的 SQL 会退化到表锁
行锁粒度小，并发度高；表锁粒度大，适合批量操作但并发差
业务中尽量通过索引字段来操作数据，避免无意中触发表锁

参考：CSDN - 行锁和表锁

Redis 的使用——排行榜实现

2024-12-13T14:49:20.000Z

需求背景

项目中常把持续使用的数据放到缓存中，以便更快响应、减少数据库操作。排行榜就是一个典型场景——如果每次用户查询都去查数据库，性能会很差。

以基于用户好友的排行榜为例，直接查库需要：获取好友 ID → 判断授权 → 获取数据 → 整合，中间还有各种异常处理，请求量上来后体验堪忧。

核心思路

Redis 的 ZSet（有序集合）是实现排行榜的核心数据结构：

有序性：每个元素有一个分数（score），Redis 根据分数排序
唯一性：每个元素唯一，不允许重复
高效操作：支持 O(log N) 的插入、删除、查找，支持按分数范围分页查询

代码实现

添加数据到排行榜

@Autowired
private RedisTemplate redisTemplate;

public R add(Double grades, String userId) {
    redisTemplate.opsForZSet().add("leaderboard", userId, grades);
    return R.ok();
}

获取指定用户排名

public R getRanking(String userId) {
    RankDTO rankDTO = new RankDTO();
    rankDTO.setUserId(userId);
    // reverseRank 从高到低排名，结果从 0 开始，+1 才是真实排名
    rankDTO.setGrades(redisTemplate.opsForZSet().reverseRank("leaderboard", userId) + 1);
    return R.ok().data("rank", rankDTO);
}

获取整体排行榜

public R getLeaderboard() {
    Set> leaderboardSet =
        redisTemplate.opsForZSet().reverseRangeWithScores("leaderboard", 0, -1);
    return R.ok().data("leaderboard", leaderboardSet);
}

踩坑与思考

1. ZSet 的实现原理？

ZSet 底层基于跳表（SkipList）和哈希表实现，兼顾有序性和高效查找。

2. 用户独立排行榜如何更新？

如果每个用户有自己的好友排行榜，好友数据变化后不方便逐个更新。建议对好友列表做缓存（增删好友时更新），再配合 ZSet 或数据库查询获取实时数据。ZSet 更适合平台维度的整体排行，如积分榜、月度爱心榜等。

3. 排行榜过期时间怎么处理？

ZSet 只能对整个集合设置过期时间，无法针对单条数据。可以用定时任务（如每天 0 点或每月 1 号 0 点）清空旧排行榜，统计当天或当月的有效记录。历史数据可单独落表用于归档。

小结

Redis ZSet 是实现排行榜的首选方案，简单高效
注意排名从 0 开始，取排名时 reverseRank + 1
排行榜过期结合定时任务即可实现按天/月轮换

参考：CSDN - Redis的使用–排行榜实现

JAVA-MQ 设置动态的过期队列

2024-12-11T03:03:11.000Z

需求背景

在开发场景中，如预约的签到，用户会有不同的预约签到时间，例如：7:00、7:30、8:00。

对于这种场景，使用定点轮询查表的方式，一方面时间颗粒度需要严格的控制，另一方面在数据库的记录一多就很浪费性能。所以可以考虑使用 MQ 的过期队列来实现功能。

核心思路

基于 RabbitMQ 的死信队列：

将消息的存活时间设置为”从当前时间到目标判断截止时间”的时间差
消息过期后自动转入死信队列
在项目中编写方法监听死信队列，触发业务逻辑

这样就实现了动态的过期时间设置，无需轮询数据库。

配置实现

1. 定义队列与死信队列

配置一个正常队列，设置一个极大的默认过期时间（如 24h），并绑定死信交换机：

@Bean
public Queue queueLog() {
    Map args = new HashMap<>();
    args.put("x-message-ttl", TTL_MAX);            // 消息最大存活时间 24h
    args.put("x-dead-letter-exchange", EXCHANGE_DLX_LOG);  // 死信交换机
    args.put("x-dead-letter-routing-key", ROUTING_KEY_LOG); // 死信路由键

    return QueueBuilder.durable(QUEUE_LOG).withArguments(args).build();
}

TTL_MAX 设置为 24h（注意单位是毫秒，24 * 60 * 60 * 1000）。

配置流程：

创建一个正常的交换机（Exchange）
创建一个正常的队列（Queue），绑定到正常交换机
定义一个死信交换机（DLX）和死信队列（DLQ）
将死信队列绑定到死信交换机
将正常队列通过参数绑定到死信交换机（第 2 步的 args）

2. 发送消息时动态设置过期时间

计算当前时间到目标时间的差值，作为消息的过期时间：

@Autowired
private AmqpTemplate rabbitTemplate;

public void sendLogMessage(String message) {
    QueryWrapper qw = new QueryWrapper<>();
    qw.eq("reservation_id", message);
    ReservationsDTO dto = reservationsMapper.selectOne(qw);

    // 计算当前时间到 startTime 的时间差
    LocalDateTime startTime = dto.getStartTime();
    Duration duration = Duration.between(LocalDateTime.now(), startTime);

    if (duration.isNegative()) {
        log.error("签到时间已过: {}", message);
        duration = Duration.ZERO;
    }

    long expirationTimeMillis = duration.toMillis();

    rabbitTemplate.convertAndSend(RabbitMQ.EXCHANGE, message, msg -> {
        msg.getMessageProperties().setExpiration(String.valueOf(expirationTimeMillis));
        return msg;
    });
}

如果需要路由键：

rabbitTemplate.convertAndSend(RabbitMQ.EXCHANGE, "路由键", message, msg -> {
    msg.getMessageProperties().setExpiration(String.valueOf(expirationTimeMillis));
    return msg;
});

3. 消费死信队列

在消费者中监听对应的死信队列，正常编写业务逻辑即可。

注意事项

设置的单个消息过期时间**不要超过队列的 x-message-ttl**（即 24h），所以在设计时要考虑极端情况的最大间隔
时间差为负数时兜底处理为 Duration.ZERO，防止消息永远不过期
setExpiration 接收的是字符串类型的毫秒数

小结

利用死信队列 + 动态 TTL，可以优雅地实现定时触发，避免轮询数据库
核心是三个配置：正常队列绑定死信交换机、设置队列最大 TTL、发送时动态计算过期时间
适用于预约签到、订单超时取消等场景

参考：CSDN - JAVA-MQ设置动态的过期队列

Linux 常用命令 & 高并发调优笔记

2024-11-21T12:34:00.000Z

Linux 命令通用性

大部分核心命令（ls, cd, cat, grep, find 等）在不同发行版中通用，遵循 POSIX 标准。

差异主要在包管理器：

发行版	包管理器
Red Hat / CentOS / Fedora	`yum` / `dnf`
Debian / Ubuntu / Mint	`apt`
Arch / Manjaro	`pacman`
openSUSE	`zypper`

常用文件操作

cat file             # 显示文件内容
tail -n 10 file      # 查看文件末尾 10 行
tail -n 10 file | grep "error"  # 结合 grep 过滤

mkdir dir            # 创建文件夹
mkdir -p a/b/c       # 创建多层级目录
mkdir -v dir         # 显示创建详情

rmdir dir            # 删除空目录
rm -r dir            # 递归删除非空目录
rm -rf dir           # 强制删除（慎用！）

touch file           # 创建文件
rm file              # 删除文件

写入与条件判断

# 覆盖写入
echo "Hello" > file.txt

# 追加写入
echo "World" >> file.txt

# sudo 只能提升命令本身的权限，不能提升重定向(>)的权限
# 正确做法：
sudo sh -c 'echo "config" > /etc/somefile'

# 文件存在判断
if [ -f "./path/to/file" ]; then
    echo "文件存在"
else
    echo "文件不存在"
fi

高并发常见调优

JVM 层面

垃圾回收（GC）：

高并发下频繁 GC 会导致停顿
调优方向：使用 G1 / ZGC、增大堆内存（-Xms / -Xmx）、减少短生命周期对象

缓存区满：

增加缓存区大小
优化缓存策略（如 LRU）

Nginx 层面

1
2
3

worker_processes auto;           # 增加工作进程数
keepalive_timeout 65;            # 调整连接超时
proxy_cache_path /path levels=1:2 keys_zone=my_cache:10m;  # 开启缓存

系统参数

# 查看当前值
sysctl net.ipv4.tcp_max_syn_backlog
sysctl net.core.somaxconn

# 临时修改（重启失效）
sysctl -w net.ipv4.tcp_max_syn_backlog=2048
sysctl -w net.core.somaxconn=256

# 永久修改
echo "net.ipv4.tcp_max_syn_backlog = 2048" >> /etc/sysctl.conf
echo "net.core.somaxconn = 256" >> /etc/sysctl.conf
sysctl -p

磁盘空间

df -h                           # 查看磁盘使用情况

# 治标——清理临时文件
sudo rm -rf /tmp/*

# 清理包管理器缓存
sudo apt-get clean              # Debian 系
sudo yum clean all              # Red Hat 系

01 背包：Knapsack 1

2024-10-25T13:21:00.000Z

背景

第一次在 AtCoder 上做到 01 背包，发现虽然是模板题，但自己写的时候还是卡了不少地方——主要是 Java 的数组类型和下标转换细节。

题目描述

给定 N 个物品，每个物品有重量 w[i] 和价值 v[i]。背包容量为 W，求能装入的最大总价值。

每个物品最多选一次，经典的 01 背包问题。

思路分析

01 背包的标准做法是用一维 DP 数组，容量从大到小遍历，保证每个物品只取一次。

转移方程：

1	f[j] = max(f[j - w[i]] + v[i], f[j])

其中 f[j] 表示容量为 j 时能获得的最大价值。

关键细节：

数据范围较大，f 数组必须开 long，否则会溢出
Java 中数组下标必须是 int，而 w[i] 存为 long 时需要用 (int) 强转
空间上提前初始化一个足够大的数组（如 maxn = 100005），避免动态扩容

代码实现

import java.util.Scanner;

public class Y {
    static final int maxn = 100005;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        long[] f = new long[maxn];
        long[] w = new long[maxn];
        long[] v = new long[maxn];

        for (int i = 1; i <= n; ++i) {
            w[i] = scanner.nextLong();
            v[i] = scanner.nextLong();
        }

        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= w[i]; --j) {
                f[j] = Math.max(f[j - (int) w[i]] + v[i], f[j]);
            }
        }

        System.out.println(f[m]);
    }
}

复杂度分析

时间复杂度：O(N × W)，其中 N 为物品数，W 为背包容量
空间复杂度：O(W)，使用一维滚动数组优化后的结果

小结

01 背包的一维写法要倒序遍历容量，这是核心套路
Java 做题时注意 long 数组和 (int) 类型转换，各语言的类型细节不同容易在这里耽误时间
初始化一个大数组而不是用 ArrayList 或动态结构，在竞赛中更省心

MySQL 连接管理常用命令

2024-10-15T15:33:00.000Z

密码说明

桌面 SQL：常用密码
虚拟机中 MySQL：root

查看连接信息

-- 查看当前的连接实例
SHOW FULL PROCESSLIST;

-- 查看连接总数
SELECT COUNT(*) FROM INFORMATION_SCHEMA.PROCESSLIST;

最大连接数

-- 查看最大连接数
SHOW VARIABLES LIKE '%max_connections%';

-- 临时设置（重启后失效）
SET GLOBAL max_connections = 200;

配置文件方式修改需要重启数据库，但修改是永久的。

关于轮询和定时任务

2024-08-28T13:39:00.000Z

背景

对于过期状态修改（如订单超时取消），有两种常见处理方式：轮询和 MQ 延时消息。

方案一：轮询

直接暴力扫表，对不合法状态进行修改。

缺点：

即使没有订单也会去扫表，浪费资源
数据量大时不够友好

方案二：MQ 延时消息

只在有订单时才触发查询和修改：

@Autowired
private RabbitTemplate rabbitTemplate;

public void sendDelayedOrderMessage(Long orderId) {
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setHeader("x-delay", 900000); // 15 分钟
    Message message = MessageBuilder.withBody(String.valueOf(orderId).getBytes())
                                    .andProperties(messageProperties)
                                    .build();
    rabbitTemplate.convertAndSend("order.delay.queue", message);
    log.info("发送延时消息：{}", orderId);
}

消费者处理：

@Autowired
private OrderMapper orderMapper;

@RabbitListener(queues = "order.delay.queue")
public void handleDelayedOrderMessage(Message message) {
    String orderIdStr = new String(message.getBody());
    Long orderId = Long.parseLong(orderIdStr);
    Orders order = orderMapper.getById(orderId);
    if (order != null && order.getStatus() == Orders.PENDING_PAYMENT) {
        order.setStatus(Orders.CANCELLED);
        order.setCancelReason("订单超时，自动取消");
        order.setCancelTime(LocalDateTime.now());
        orderMapper.update(order);
        log.info("处理订单超时：{}", orderId);
    }
}

优点：只在有订单时查询，每次处理的数据量可控。

缺点：同一时刻数据量非常大时，部分数据可能在限定时间内得不到处理（可以通过增加消费者、使用死信队列等方式缓解，但也会引入消息幂等性等新问题）。

小结

两种方案各有利弊：

轮询：实现简单，高峰时处理能力强，但空闲时浪费资源
MQ 延时消息：按需触发，但瞬时高峰吞吐有限

没有银弹，所谓架构就是在各种不完美中找到当下最合适的妥协。

Spring Boot 邮件发送

2024-08-28T13:21:00.000Z

前置准备

使用 QQ 邮箱发送邮件需要先开启 POP3/IMAP/SMTP 服务，并在授权码管理页面生成授权码。

开启位置：QQ 邮箱 → 设置 → 账户 → POP3/IMAP/SMTP/Exchange/CardDAV 服务
生成的授权码作为配置中的 password

配置文件

mail:
  host: smtp.qq.com
  port: 465
  username: 1271631984@qq.com
  password: tysatqekxlsbfjig
  properties:
    mail:
      smtp:
        auth: true
        socketFactory:
          class: javax.net.ssl.SSLSocketFactory
          fallback: false
          port: 465

发送示例

void email() {
    final String username = "1271631984@qq.com";
    final String password = "tysatqekxlsbfjig";
    final String to = "2166702512@qq.com";

    MimeMessage mimeMessage = javaMailSender.createMimeMessage();
    MimeMessageHelper mimeMessageHelper;
    try {
        mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
        mimeMessageHelper.setTo(to);
        mimeMessageHelper.setFrom(username);
        mimeMessageHelper.setSubject("匹配成功！脱离单身系列");
        mimeMessageHelper.setText("周*浚 你好,"
                + "\n\n介于你之前在网上对于单身现状的苦恼困惑 "
                + "我司根据你之前所填写信息 现已为你匹配到合适的另一半 "
                + "可通过添加对方qq好友进行进一步了解 QQ:2107886532");
        javaMailSender.send(mimeMessage);
        System.out.println("发送成功");
    } catch (MessagingException e) {
        e.printStackTrace();
        System.out.println("邮件发送失败");
    }
}

小结

密码使用 QQ 邮箱的授权码，不是登录密码
生产环境应将邮件发送封装成独立方法，接收发送对象和内容参数

Vagrant & Docker 常用命令

2024-08-12T12:10:00.000Z

Vagrant

vagrant up          # 启动虚拟机
vagrant ssh         # SSH 连接

# 默认 root 密码
root password: vagrant

权限

1 2	chmod -R 777 文件夹路径 # 递归设置所有人可读写执行 sudo # 以 root 权限执行

Docker

# 配置镜像源
sudo vi /etc/docker/daemon.json

# 重载配置并重启
sudo systemctl daemon-reload
sudo systemctl restart docker

# 查看 Docker 信息
sudo docker info

# 查看所有运行中的容器
docker ps -a

SSH

1	ssh qi@192.168.11.128 # 界面化连接远程主机

我的记录

2024-07-18T16:00:00.000Z

CSDN

Gitee 贡献

2026

2025

2024

DFS 入门：从汉诺塔到 n 的全排列

2024-06-29T09:53:00.000Z

上学期在 JavaEE 学习中第一次接触 DFS 思想，是从汉诺塔问题开始的。汉诺塔很适合作为递归入门：把一个大问题拆成“先移动上面的盘子、再移动当前盘子、最后移动剩下的盘子”。

这学期补算法题时，又遇见了一个很典型的问题：n 的全排列。

题目描述

输入一个数字 n。

输出从 1 到 n 这 n 个数字组成的所有长度为 n 的排列。

例如输入 3，可以输出：

DFS 思想

这道题仍然是 DFS 的思想。

写递归时，可以先考虑“当前这一步做什么”，或者假设当前只有一步要完成。这一点很像分治：先把当前层的问题想清楚，再把剩下的问题交给下一层递归。

在全排列里，当前这一步就是：

给当前位置 temp 选择一个还没有使用过的数字。

比如第三个数字也可能成为第二个位置上的数字，所以每一层都要从 1 到 n 重新枚举。但为了避免数字重复使用，需要额外开一个数组 vis 记录每个数字是否已经被用过。

状态记录与还原

和普通递归相比，这里的新技巧是多使用一个数组记录状态：

nums[temp]：记录当前位置选择了哪个数字
vis[i]：记录数字 i 是否已经被使用

每次选择一个数字后，先把它标记为已使用，然后进入下一层递归。

递归结束回来以后，还要把这个数字恢复为未使用，方便下一次枚举。这一步叫“回溯”，也就是把当前选择造成的状态影响撤销掉。

Java 代码

static void test(int temp) {
    if (temp == n + 1) {
        for (int i = 1; i <= n; i++) {
            System.out.print(nums[i]);
        }
        System.out.println();
        return;
    }

    for (int i = 1; i <= n; i++) {
        if (vis[i] != 1) {
            nums[temp] = i;
            vis[i] = 1;
            test(temp + 1);
            vis[i] = 0;
        }
    }
}

递归过程理解

可以把 temp 理解为“当前正在填写第几个位置”。

当 temp == n + 1 时，说明从第 1 个位置到第 n 个位置都已经填好了，这时输出一次答案。

否则，就枚举所有数字：

如果数字 i 没有被使用，就把它放到当前位置。
标记 vis[i] = 1，表示这个数字已经被当前排列占用。
递归处理下一个位置，也就是 test(temp + 1)。
回来后执行 vis[i] = 0，恢复现场，让后面的排列还能继续使用这个数字。

小结

DFS 写法的关键不是一开始就想完整棵搜索树，而是先想清楚当前层要做什么。

全排列问题中，当前层要做的事情就是：给当前位置选择一个未使用过的数字。为了让每一层都能正确枚举，需要用 vis 数组记录状态，并在递归返回时还原状态。

这就是 DFS + 回溯最基础、也最常见的一种模板。

Frog 2

2024-06-29T09:52:00.000Z

背景

Frog 1 的进阶版，将固定跳跃步数改成了动态步数。核心思路不变，但多了初始化细节。

思路分析

定义 dp[i] 为跳到第 i 个石头的最小花费。

每次可以从第 i 个石头跳到 i+1 到 i+k 范围内的任意石头：

1	dp[i + j] = min(dp[i + j], dp[i] + \|a[i] - a[i + j]\|)

关键细节：因为取的是最小值，而 int[] 默认值为 0，需要先初始化成极大值，同时 dp[1] = 0（从起点开始，花费为 0）。

代码实现

int[] dp = new int[n + 1];
for (int i = 1; i <= n; i++) dp[i] = Integer.MAX_VALUE;
dp[1] = 0;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= k; j++) {
        if (i + j <= n)
            dp[i + j] = Math.min(dp[i + j], dp[i] + Math.abs(a[i] - a[i + j]));
        else break;
    }
}
System.out.println(dp[n]);

小结

线性 DP，但步数不固定，加一层循环即可
注意初始化：取最小值时一定要把 dp 初始化为极大值，否则默认的 0 会干扰结果

P1075 [NOIP2012 普及组] 质因数分解

2024-06-29T09:52:00.000Z

思路分析

从后往前枚举虽然直觉上更直接（要找大的那个质数），但当数据很大时，从 n-1 开始往前枚举效率极差，会 TLE。

反过来从前往后枚举，找到第一个能被 n 整除的数，它就是较小的那个质因数，那么 n / i 就是较大的那个质因数，直接输出。

代码实现

long n = nextLong();
long i = 2;
while (i < Math.sqrt(n)) {
    if (n % i == 0) {
        System.out.println(n / i);
        return;
    }
    i++;
}

小结

从前往后枚举往往比从后往前快得多
枚举到 sqrt(n) 即可，因为因数成对出现

P3397 地毯

2024-04-07T13:26:00.000Z

考点

二维差分。

思路分析

暴力模拟会超时。

一维差分的思路：对数组 a 构造差分数组 b，其中 b[i] = a[i] - a[i-1]。对区间 [l, r] 加上 c 时，只需 b[l] += c、b[r+1] -= c，最后前缀和还原。

对于二维，在 (x1, y1) 到 (x2, y2) 矩形区域加 1，差分操作是四个点：

d[x1][y1]   += 1
d[x1][y2+1] -= 1
d[x2+1][y1] -= 1
d[x2+1][y2+1] += 1

最后对每行做前缀和即可得到最终的矩阵。

代码实现

for (int l = 1; l <= n; l++) {
    for (int r = 1; r <= n; r++) {
        map[l][r] += map[l][r-1];
        System.out.print(map[l][r] + " ");
    }
    System.out.println();
}

小结

差分的核心思想：区间修改转化为端点操作，避免暴力
二维差分可以拆成四个单点修改，再前缀和还原