AI on Coder_Studio

一篇搞懂：LangChain4j结构化输出、TokenStream、SSE、Flux、Reactor到底是什么？

Thu, 26 Mar 2026 20:42:49 +0000

结构化输出、TokenStream、SSE、Flux、Reactor这几个概念刚接触时感觉很混乱，本文就来理一理，我用【AI生成一个电商商品详情页】的真实项目场景，把这些概念串起来，从业务需求到底层技术，一次性搞明白。

LangChain4j结构化输出

结构化输出是LangChain4j里的一个核心功能，能强制大模型返回标准的JSON/POJO组件树对象，而不是一段诸如“我给你加个按钮、加个图片”的自然语言。

之前你让AI生成商品详情页，它可能返回：

“好的，我帮你生成了一个详情页，顶部有个轮播图放3张商品图，中间有商品标题、价格、库存，底部有个‘立即购买’的红色按钮…”

然后你还得写自己大量文本解析逻辑，甚至还要用正则去提取轮播图数量、按钮颜色，又繁琐又容易出错，而且根本没法直接渲染成 Web 组件。

用了结构化输出，AI 会直接返回标准 JSON，之后 LangChain4j 会自动把 JSON 转成 Java 对象。底层默认使用 Jackson（Java 最主流的 JSON 库），只需要提前定义好页面结构的模板类，系统就能自动完成字段映射，完全不用写任何解析代码，直接就能喂给前端的渲染引擎。

TokenStream + SSE

TokenStream是LangChain4j提供的流式API，大模型生成一个Token（大概是一个字、半个JSON键或值），就立刻推给你，不用等整个组件树JSON生成完；

SSE（Server-Sent Events），把TokenStream里的JSON片段，实时推给前端的渲染引擎，实现“轮播图先出来、标题再出来、按钮最后出来”的逐个渲染效果。

之前你让AI生成一个复杂的Web应用，要等10-30秒整个JSON生成完，才能一次性渲染给用户，用户需要在空白的预览区页面长时间等待。

用了TokenStream + SSE，AI生成完一个完整的组件JSON片段，前端就立刻渲染这个组件，用户能实时看到进度。

Flux & Reactor

Reactor是Spring官方的响应式编程框架，专门用来处理高并发、异步、流式的场景；

Flux是Reactor的核心类之一，代表0到N个元素的异步序列，刚好对应AI生成的JSON片段流（一个JSON片段就是一个元素）。

如果用传统的同步编程，几百个用户同时请求生成Web应用，你需要开几百个线程，每个线程都要等10-30秒AI生成完，服务器的CPU、内存直接就爆了，根本扛不住。

用了 Flux + Reactor，就能彻底解决这个问题：

它是完全异步非阻塞 + 事件驱动的模型 —— 发起 AI 调用后，线程立刻释放去处理其他请求，绝不死等；等 AI 生成 Token 后，再主动通知线程来处理推送，1 个线程能同时管理几百个请求，所以只用 10-20 个线程就能扛住几百甚至上千的并发。

另外，它还自带背压机制：前端网速慢，服务端就自动放慢推送速度；前端快，就加快推送，永远不会让前端浏览器因为数据堆积而卡死。

一张图搞懂

【面试真题拆解】为什么用SSE做流式输出？和WebSocket有啥区别？

Wed, 25 Mar 2026 17:41:32 +0000

面试官问：

“你项目里用了SSE做流式输出，为什么选SSE？它的原理你知道吗？为什么不用WebSocket？”

为什么用SSE做流式输出？

一句话：

SSE 是为服务器单向给客户端推数据的场景量身定做的，完美匹配 AIGC 流式打字机的需求，开发简单、好用、运维成本低。

类比：

SSE 就像广播电台：电台单向给你播新闻、播音乐，你只能听，不能对着电台说话；
WebSocket 就像打电话：你和对方可以双向说话，你一句我一句，实时互动。

SSE流式输出的原理

SSE是Server-Sent Events（服务器发送事件），本质上是一条由服务器控制生命周期的持久化 HTTP 长连接，在数据推送周期内保持打开，不会像普通 HTTP 请求一样响应完成就立刻关闭。

完整的流程就是：

客户端发起请求

浏览器向服务器发起一个普通的HTTP GET请求，但请求头里要加 Accept: text/event-stream，告诉服务器：“我要接收流式数据，别给我返回普通网页”；

服务器建立长连接

服务器收到请求后，不立刻返回完整响应，而是保持这条HTTP连接一直打开，不关闭；

服务器持续推数据

服务器有新数据了（比如AI生成了一个字），就通过这条打开的连接，把数据推给客户端；

SSE 有固定的标准文本格式，每段数据以data:开头、\n\n结尾，刚好适配大模型逐 Token 生成的流式输出，后端生成一个 Token 就推一次，前端无需额外做格式解析，直接渲染成打字机效果；

客户端解析数据

浏览器收到数据后，自动解析，触发 onmessage 事件，前端把数据展示出来；

连接结束或自动重连

如果数据推完了，服务器就会主动关闭连接；

如果连接意外断开（非手动关闭、非服务器返回 204 状态码），SSE 自带自动重连机制，浏览器会自动重新发起请求，还会通过请求头Last-Event-ID带上最后接收的消息 ID，后端可据此补发丢失的内容，避免 AI 回答断句缺失，建立新连接后继续接收数据。

为什么不用WebSocket？

WebSocket 是为双向实时交互场景设计的，对于 AI 流式输出这个纯服务器单向推数据的场景，有点那什么杀鸡用牛刀了，并且额外增加了开发、运维成本，完全没有必要。

对比项	SSE（Server-Sent Events）	WebSocket
通信模式	单工，纯单向通信：仅支持服务器向客户端主动推送数据，客户端只能被动接收	全双工，双向通信：客户端和服务器可以同时、双向主动发送数据，无请求 - 响应的限制
协议本质	标准 HTTP 应用层协议，完全兼容所有 HTTP 基础设施（Nginx、CDN、网关、防火墙），无需额外配置	独立的应用层协议，底层基于 TCP，仅握手阶段复用 HTTP，握手完成后需协议升级，部分内网网关、WAF 会拦截升级请求
开发复杂度	极低：浏览器原生提供`EventSource` API，前端几行代码即可实现；后端仅需开发普通 HTTP 接口保持连接推送数据，无需额外处理协议逻辑	较高：需要自行处理连接握手、心跳保活、断线重连、TCP 粘包拆包、帧解析等逻辑，前后端都需要额外的开发工作量
自动重连	原生支持：浏览器内置自动断线重连机制，无需额外开发	无原生支持：需要自行实现心跳检测和断线重连逻辑
适用场景	服务器单向推送场景：AIGC 流式打字机效果、股票行情推送、直播弹幕、新闻实时更新	双向实时交互场景：即时通讯、实时多人游戏、视频会议、物联网设备双向控制

Spring Boot + 通义千问 AI 数据分析助手：一句话生成 SQL + 图表 + 智能结论

Tue, 24 Mar 2026 16:19:59 +0000

需求分析

在数据爆炸的时代，业务人员最痛苦的事就是：不会写 SQL，却每天都要查数据。

我用 Spring Boot 3.2 + 通义千问 API打造了一个AI 数据分析助手，实现了“一句话搞定一切”：

用户输入一句自然语言 → 系统自动解析意图 → 智能生成 SQL → 执行查询 → 自动出图表 + 专业分析结论

项目效果演示

1. 自动生成的 SQL

2. 查询结果数据表

3. ECharts 自动可视化 + 智能结论

技术栈

后端：Spring Boot 3.2 + MyBatis-Plus + JdbcTemplate + FastJSON2 + Lombok
AI：通义千问 Qwen（RestTemplate 调用）
前端：Vue3（CDN）+ Element Plus + ECharts 5（单文件 index.html）
数据库：MySQL 8（附 schema.sql + 200 条演示数据）
其他：SSE 流式响应、动态数据源、SQL 安全正则校验

核心功能

智能 SQL 生成：结合表结构元数据 + Few-Shot Prompt，准确率大幅提升
SQL 安全校验：自动拦截 DROP/DELETE 等危险操作
流式 SSE 实时推送：意图解析 → SQL 生成 → 查询执行 → 结论生成，每一步都有进度条
ECharts 自动适配：柱状图、折线图、饼图、表格智能选择
智能分析结论：通义千问生成 2-3 句专业总结
支持动态数据源：可随时接入企业已有业务数据库

3 步快速上手

下载项目（文末附源码）
配置环境变量：

`1`	`QWEN_API_KEY=你的通义千问密钥`

启动：

1
2

# 先执行 sql/schema.sql 初始化数据库
mvn spring-boot:run

浏览器打开：http://localhost:8080

可以作为学习 LLM + 数据库落地的案例。

完整源码 + schema.sql + 使用文档 已打包好：https://download.csdn.net/download/qq_44678890/92757775

【面试真题拆解】Java里面的线程池都有哪些参数？

Sun, 22 Mar 2026 15:09:10 +0000

那下一个问题，面试官接着问：

“ Java里面的线程池都有哪些参数？”

我当时就记得“核心线程数、最大线程数”，其他的应该还有5个，支支吾吾答不上来，直接就凉了。

线程池是用来管理线程的，避免频繁创建和销毁线程带来的性能开销。

类比一下工厂招工：

不用线程池

来一个任务就招一个新工人（创建线程），任务干完就辞退（销毁线程），频繁招工辞退，效率极低，还费钱；

用线程池

工厂提前招好一批固定工人（核心线程），任务来了直接让固定工人干，固定工人忙不过来就把任务放待办队列（工作队列），队列也满了就临时招几个临时工（非核心线程），临时工没活干了过段时间就辞退，效率高，还省钱。

线程池的7个核心参数

Java线程池的核心类是 ThreadPoolExecutor，它的构造方法有7个参数：

1. corePoolSize：核心线程数

工厂的正式工数量。

正式工是工厂的“长期工”，默认情况下，就算没活干，也不会被辞退；

任务来了，先让正式工干，正式工没满的话，直接创建正式工执行任务。

2. maximumPoolSize：最大线程数

工厂的正式工+临时工的总数量。

正式工忙不过来，待办队列也满了，就会招临时工；

正式工+临时工的总数，不能超过最大线程数。

3. keepAliveTime：空闲线程存活时间

工厂的临时工没活干的时候，多久会被辞退。

只有临时工（非核心线程）会被回收，正式工（核心线程）默认不会被回收；

但是，如果设置了 allowCoreThreadTimeOut(true)，正式工没活干了，过了这个时间也会被辞退。

4. unit：时间单位

空闲线程存活时间的单位。

比如 TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分钟）、TimeUnit.HOURS（小时）。

5. workQueue：工作队列

工厂的待办任务队列。

正式工（corePoolSize）都在忙，新任务来了就先放进待办队列，等正式工有空了再从队列里拿任务干。

6. threadFactory：线程工厂

给工厂的工人起名字的。

用来创建新线程，给线程设置名字、优先级、是否是守护线程等。

7. handler：拒绝策略

工厂的任务太多了，正式工、临时工、待办队列都满了，怎么处理新任务，就是靠这个参数定义的。

线程池的执行流程

提交新任务

工厂来了一个新任务；

判断核心线程数

先看正式工（corePoolSize）有没有满，没满的话，直接招一个正式工（创建核心线程）执行任务；

判断工作队列

如果正式工满了，就看待办队列（workQueue）有没有满，没满的话，把任务放进队列，等正式工有空了再拿；

判断最大线程数

如果队列也满了，就看正式工+临时工的总数（maximumPoolSize）有没有满，没满的话，招一个临时工（创建非核心线程）执行任务；

执行拒绝策略

如果最大线程数也满了，就执行拒绝策略（handler），处理这个新任务；

任务执行完

线程执行完任务，会从队列里拿下一个任务继续干；

空闲线程回收

如果是临时工（非核心线程），没活干的时间超过了 keepAliveTime，就会被回收（辞退）。

4种默认拒绝策略

拒绝策略	作用	适用场景
AbortPolicy（默认）	直接抛出RejectedExecutionException异常，拒绝执行新任务	对数据一致性要求高的场景，任务不能丢，必须让调用者知道任务被拒绝了
CallerRunsPolicy	由提交任务的线程（调用者线程）自己执行这个任务	对性能要求不高，任务不能丢的场景，比如日志记录
DiscardPolicy	直接丢弃新任务，不抛异常，也不做任何处理	对数据一致性要求不高，丢几个任务没关系的场景，比如非核心的监控数据上报
DiscardOldestPolicy	丢弃队列里最老的任务（等待时间最长的任务），然后把新任务放进队列	对数据一致性要求不高，但想尽量执行新任务的场景

ThreadPoolExecutor 的构造方法

import java.util.concurrent.*;

/**
 * 线程池示例
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 定义线程池的7个核心参数
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5, // corePoolSize：核心线程数（5个正式工）
                10, // maximumPoolSize：最大线程数（5个正式工+5个临时工）
                60, // keepAliveTime：空闲线程存活时间（60秒）
                TimeUnit.SECONDS, // unit：时间单位（秒）
                new ArrayBlockingQueue<>(100), // workQueue：有界队列（容量100）
                Executors.defaultThreadFactory(), // threadFactory：默认线程工厂
                new ThreadPoolExecutor.AbortPolicy() // handler：默认拒绝策略（抛异常）
        );

        // 提交任务
        for (int i = 0; i < 200; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务：" + taskId);
            });
        }

        // 关闭线程池
        threadPool.shutdown();
    }
}

【面试真题拆解】Java的Static关键字到底怎么用？

Sun, 22 Mar 2026 13:06:05 +0000

面试官上来就问：

“ 那个Java里面的Static关键字，一般是怎么用？”

一句话：

Static是“类级别的”，不是“实例级别的”。

被Static修饰的东西，属于整个类，所有实例共用一份，不用new对象就能直接用；

而没被Static修饰的东西，属于单个实例，每个实例有自己的一份，必须new对象才能用。

对比项	静态（Static）	实例（非Static）
归属	属于整个类	属于单个实例
内存位置	方法区（JDK8 之后叫元空间）	堆内存
访问方式	类名.（变量/方法），或（实例.变量/方法）（不推荐）	必须通过实例.变量/方法访问
共享性	所有实例共用一份	每个实例有自己的一份
初始化时机	类加载时初始化	创建实例时初始化
访问限制	只能直接访问静态成员	可以访问静态成员和实例成员

1. 静态变量

静态变量就像是整个类共享的“公共储物柜”，所有实例共用这一个柜子，你放进去的东西，别人也能拿到；而实例变量是每个实例自己的“私人储物柜”，互不干扰。

举个例子，用静态变量做全局计数器

/**
 * 网站访问计数器
 */
public class WebsiteCounter {
    // 静态变量：所有实例共用，统计总访问次数
    public static int totalVisitCount = 0;
    // 实例变量：每个实例自己的，统计单个用户的访问次数
    public int userVisitCount = 0;

    /**
     * 访问方法
     */
    public void visit() {
        // 修改静态变量：总访问次数+1
        totalVisitCount++;
        // 修改实例变量：单个用户访问次数+1
        userVisitCount++;
    }

    public static void main(String[] args) {
        // 用户1访问
        WebsiteCounter user1 = new WebsiteCounter();
        user1.visit();
        user1.visit();
        System.out.println("用户1访问次数：" + user1.userVisitCount); // 输出2
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出2

        // 用户2访问
        WebsiteCounter user2 = new WebsiteCounter();
        user2.visit();
        System.out.println("用户2访问次数：" + user2.userVisitCount); // 输出1
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出3
    }
}

2. 静态方法

静态方法是属于类的“公共工具”，不用new对象，直接通过【类名.方法名】就能调用，而实例方法是属于单个实例的，必须new对象之后才能调用。

举个例子，用静态方法做工具类

/**
 * 字符串工具类
 */
public class StringUtils {
    // 私有构造方法：从根源上禁止外部代码 new StringUtils()
    // 工具类全是静态方法，完全不需要实例化，这样做能强制大家用[类名.方法名]的正确用法
    private StringUtils() {}

    /**
     * 静态方法：判断字符串是否为空
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    /**
     * 静态方法：字符串反转
     */
    public static String reverse(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return new StringBuilder(str).reverse().toString();
    }

    public static void main(String[] args) {
        // 直接通过类名调用静态方法，不用new对象
        System.out.println(StringUtils.isEmpty("")); // 输出true
        System.out.println(StringUtils.reverse("hello")); // 输出olleh
    }
}

3. 静态代码块

静态代码块是类加载的时候执行一次，且只执行一次的代码块，用来初始化静态变量或者做一些类级别的准备工作（比如加载配置文件、初始化数据库连接池）。

举个例子，用静态代码块初始化静态配置

/**
 * 配置类
 */
public class Config {
    // 静态变量：数据库连接地址
    public static String dbUrl;
    public static String dbUsername;
    public static String dbPassword;

    // 静态代码块：类加载时执行一次，初始化静态变量
    static {
        System.out.println("静态代码块执行，开始初始化配置...");
        // 模拟从配置文件读取配置
        dbUrl = "jdbc:mysql://localhost:3306/test";
        dbUsername = "root";
        dbPassword = "123456";
    }

    // 实例代码块：创建实例时执行，每次new都执行
    {
        System.out.println("实例代码块执行...");
    }

    // 构造方法：创建实例时执行，每次new都执行
    public Config() {
        System.out.println("构造方法执行...");
    }

    public static void main(String[] args) {
        // 第一次访问Config类，触发类加载，静态代码块执行
        System.out.println("数据库地址：" + Config.dbUrl);
        System.out.println("---");
        // new第一个实例，实例代码块和构造方法执行
        new Config();
        System.out.println("---");
        // new第二个实例，实例代码块和构造方法执行，但静态代码块不再执行
        new Config();
    }
}

小贴士

静态代码块只在类第一次被加载时执行一次，之后不管new多少个实例，都不会再执行。

4. 静态内部类

静态内部类是属于外部类的“独立房间”，不用依赖外部类的实例就能直接创建，而非静态内部类是属于外部类实例的“附属房间”，必须先有外部类实例才能创建。

静态内部类的作用是：

利用 Java 的类加载时机，实现了懒加载（用的时候才创建）+ 线程安全（JVM 保证）+ 不用加锁（性能高）的完美单例。

举个例子，用静态内部类实现线程安全的单例模式

/**
 * 单例模式：静态内部类实现
 */
public class Singleton {
    // 私有构造方法：从根源上禁止外部代码直接 new Singleton()
    private Singleton() {}

    // 静态内部类：只有第一次被访问时才会加载（实现懒加载，用的时候才创建实例，不占内存）
    // 因为是在 Singleton 类内部，所以可以访问上面的 private 构造方法
    private static class SingletonHolder {
        // 静态变量：JVM 类加载过程是天然线程安全的，这里初始化唯一的单例实例（不用加锁，性能高）
        private static final Singleton INSTANCE = new Singleton();
    }

    // 全局唯一的访问点：外部代码只能通过这里获取单例实例
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) {
        // 获取单例实例
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        // 两个实例是同一个，完美实现单例
        System.out.println(instance1 == instance2); // 输出true
    }
}

小贴士

静态变量存放在JVM的方法区（元空间），不是堆内存。
静态变量可以通过【类名.变量名】直接访问，也可以通过【实例.变量名】访问（不过，不推荐，因为容易混淆）。
因为所有线程共用同一个静态变量，多线程同时修改会出现并发问题，需要加锁保证线程安全。
因为实例变量和方法依赖具体的实例，静态方法调用时可能还没new对象，所以，静态方法只能直接访问静态变量和静态方法，不能直接访问实例变量和实例方法。
this 代表当前实例，静态方法属于类，调用时可能还没创建实例，this 根本不存在，所以，静态方法不能用 this。
静态内部类只能直接访问外部类的静态变量和静态方法，不能直接访问实例变量和实例方法。

告别腾讯云 COS，用 GitHub + jsDelivr 搭建零成本图床

Thu, 19 Mar 2026 17:10:48 +0000

我的个人项目中有这么一个功能，就是个人作品页面需要显示详情页的预览截图，这样会显得更专业一点。

但是，截图之前是存在腾讯云COS中的，最近我的腾讯云 COS 到期了，我就开始寻找替代方案。

想换 Cloudflare R2 吧，听说很香零费用，结果还要信用卡验证，我这种没有国际信用卡的人直接被拒之门外。

经过一番调研和实践，我锁定了一个纯白嫖、零成本、高速度的方案：

GitHub 仓库存储 + jsDelivr CDN 加速

本文将介绍一下如何在 Spring Boot 项目中集成这一方案。

技术选型

维度	腾讯云 COS	GitHub + jsDelivr
存储费用	按量计费/资源包（需续费）	完全免费 (建议单仓库 < 1GB，单文件 < 50MB，GitHub 有软限制)
流量费用	下行流量贵（容易被盗链刷爆）	完全免费 (jsDelivr 提供的全球加速)
支付门槛	需实名、绑定支付方式	仅需一个 GitHub 账号
国内访问	速度快，但费钱	通过 jsDelivr 加速，速度极快

准备工作

创建一个新的公开仓库（Public），例如 ObjectStorage。
生成 Personal Access Token (PAT)

在Github账户进入【Settings】➡️【Developer settings】➡️【Personal access tokens】➡️【 Tokens (classic)】。

小贴士

创建Token时必须要勾选 repo 权限，并且创建的时候就得保存好生成的 Token，因为它只会出现一次。

图片截图上传成功后，访问链接格式为：
https://cdn.jsdelivr.net/gh/用户名/仓库名@分支名/文件路径

代码实现

引入依赖

需要 OkHttp 处理网络请求，FastJSON 处理 JSON 数据。

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.10.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version>
</dependency>

application-local

为了开源安全，将敏感信息放在 application-local.yml 中，并确保该文件在 .gitignore 中。

# application-local.yml
github:
  owner: github用户名
  repo: ObjectStorage
  branch: main
  token: ghp_你的TOKEN

GithubConfig

讲原CosConfig加上@Deprecated，新增GithubConfig

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "github")
public class GithubConfig {
    private String owner;
    private String repo;
    private String branch;
    private String token;
}

GithubManager

为了模仿对象存储的 SDK，将文件转为 Base64 并调用 GitHub API 进行 PUT 上传。

将原CosManager加上@Deprecated，新增GithubManager

@Component
@Slf4j
public class GithubManager {

    @Resource
    private GithubConfig githubConfig;

    private final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(15, TimeUnit.SECONDS)
            .readTimeout(15, TimeUnit.SECONDS)
            .build();

    /**
     * 上传文件到 GitHub 仓库
     *
     * @param key  存储路径
     * @param file 本地文件
     * @return jsDelivr CDN 访问地址
     */
    public String uploadFile(String key, File file) {
        // 1. 读取文件并转为 Base64
        byte[] fileBytes = FileUtil.readBytes(file);
        String base64Content = Base64.getEncoder().encodeToString(fileBytes);

        // 2. 构建 GitHub API 请求体
        JSONObject json = new JSONObject();
        json.put("message", "upload screenshot: " + file.getName());
        json.put("content", base64Content);
        json.put("branch", githubConfig.getBranch());

        // 注意：GitHub API 路径开头不能有 /
        if (key.startsWith("/")) {
            key = key.substring(1);
        }

        String url = String.format("https://api.github.com/repos/%s/%s/contents/%s",
                githubConfig.getOwner(), githubConfig.getRepo(), key);

        RequestBody body = RequestBody.create(
                json.toJSONString(),
                MediaType.parse("application/json; charset=utf-8")
        );

        Request request = new Request.Builder()
                .url(url)
                .addHeader("Authorization", "token " + githubConfig.getToken())
                .put(body)
                .build();

        // 3. 发送请求
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                // 返回 jsDelivr CDN 链接
                return String.format("https://cdn.jsdelivr.net/gh/%s/%s@%s/%s",
                        githubConfig.getOwner(),
                        githubConfig.getRepo(),
                        githubConfig.getBranch(),
                        key);
            } else {
                log.error("GitHub 上传失败, 错误码: {}, 详情: {}", response.code(), response.body().string());
                return null;
            }
        } catch (IOException e) {
            log.error("GitHub 上传网络异常", e);
            return null;
        }
    }
}

GithubScreenshotServiceImpl

为了保留原ScreenshotServiceImpl的逻辑，新增一个GithubScreenshotServiceImpl同样也实现ScreenshotService 接口。

/**
 * GithubScreenshotServiceImpl类实现了ScreenshotService接口，提供网页截图生成并上传到 GitHub 的服务
 */
@Service("githubScreenshotService") // 指定 Bean 名称，防止和原 COS 实现冲突
@Slf4j
public class GithubScreenshotServiceImpl implements ScreenshotService {

    @Resource
    private GithubManager githubManager; // 注入新写的 GithubManager

    @Override
    public String generateAndUploadScreenshot(String webUrl) {
        ThrowUtils.throwIf(StrUtil.isBlank(webUrl), ErrorCode.PARAMS_ERROR, "网页URL不能为空");
        log.info("开始生成网页截图(GitHub方案)，URL:{}", webUrl);

        // 1. 调用工具方法保存网页截图到本地
        String localScreenshotPath = WebScreenshotUtils.saveWebPageScreenshot(webUrl);
        ThrowUtils.throwIf(StrUtil.isBlank(localScreenshotPath), ErrorCode.OPERATION_ERROR, "本地截图生成失败");

        try {
            // 2. 调用方法将本地截图上传到 GitHub
            String githubUrl = uploadScreenshotToGithub(localScreenshotPath);
            ThrowUtils.throwIf(StrUtil.isBlank(githubUrl), ErrorCode.OPERATION_ERROR, "截图上传 GitHub 失败");

            log.info("网页截图生成并上传 GitHub 成功: {} -> {}", webUrl, githubUrl);
            return githubUrl;
        } finally {
            // 3. 清理本地文件
            cleanupLocalFile(localScreenshotPath);
        }
    }

    private String uploadScreenshotToGithub(String localScreenshotPath) {
        if (StrUtil.isBlank(localScreenshotPath)) {
            return null;
        }

        File screenshotFile = new File(localScreenshotPath);
        if (!screenshotFile.exists()) {
            log.error("截图文件不存在: {}", localScreenshotPath);
            return null;
        }

        // 生成文件名
        String fileName = UUID.randomUUID().toString().substring(0, 8) + "_compressed.jpg";
        // 生成 GitHub 存储路径
        String githubKey = generateScreenshotKey(fileName);

        // 调用 GitHub 管理器
        return githubManager.uploadFile(githubKey, screenshotFile);
    }

    private String generateScreenshotKey(String fileName) {
        String datePath = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
        // 注意：GitHub 路径不建议以 / 开头
        return String.format("screenshots/%s/%s", datePath, fileName);
    }

    private void cleanupLocalFile(String localFilePath) {
        File localFile = new File(localFilePath);
        if (localFile.exists()) {
            File parentDir = localFile.getParentFile();
            FileUtil.del(parentDir);
            log.info("本地截图临时文件已清理: {}", localFilePath);
        }
    }
}

小贴士

这里有一个问题需要注意，@Deprecated 只是给程序员看的“警告”标签，它并不能阻止 Spring 扫描并加载这个 Bean。

所以，为了避免Spring 在启动时发现有两个类都实现了 ScreenshotService 接口，并且都加上了 @Service 注解。

当其他地方需要注入 ScreenshotService 时，Spring 不知道该选哪一个的问题。

需要在ScreenshotServiceImpl类中添加@Deprecated 的同时，把@Service 注解注释掉。

// @Service  <-- 把这个注释掉，Spring 就不会把它当成一个 Bean 加载了
@Slf4j
@Deprecated
public class ScreenshotServiceImpl implements ScreenshotService {
    // ... 原有的代码
}

之后项目的预览界面就可以看到截图了：

23种设计模式，一次性讲明白

Thu, 19 Mar 2026 12:50:01 +0000

设计模式其实就是前辈们写代码踩了无数坑，总结出来的代码编写最佳实践，专门用来解决特定场景下的代码复用、解耦、扩展性问题。

可以分为创建型模式、结构型模式、行为型模式三类。

分类	核心作用	包含的设计模式	数量
创建型模式	解决对象怎么创建的问题，解耦对象的创建和使用	单例、工厂方法、抽象工厂、建造者、原型	5种
结构型模式	解决类/对象怎么组合的问题，不修改原有代码实现功能扩展	适配器、桥接、组合、装饰、外观、享元、代理	7种
行为型模式	解决类/对象之间怎么交互、职责怎么分配的问题，实现灵活的通信和流程控制	模板方法、命令、迭代器、观察者、中介者、备忘录、解释器、状态、策略、职责链、访问者	11种

记忆口诀

创建型口诀（5种）

单身汉在工厂抽象建原型。

一个单身汉，在工厂里用抽象方法，建造了一个原型。

结构型口诀（7种）

桥上代理卖装饰，组合适配享外观。

桥上的代理商在卖装饰品，把零件组合适配好，让你享受精美外观。

行为型口诀（11种）

访客观察定策略，模板迭代改状态，备忘命令交中介，解释责任一条链。

访客观察后定下策略，按模板迭代改变状态，把备忘录和命令交给中介，出了问题沿责任链逐一解释。

创建型模式

不让你自己new对象，把对象创建的逻辑封装起来，和业务代码解耦。

1. 单例模式

整个系统里，这个类有且只有一个实例对象，不管你在哪获取，拿到的都是同一个东西。

类比

就像公司里只有一个 CEO，不管哪个部门找，对接的都是同一个人。

适用场景

Spring容器里的单例Bean、全局配置类、日志对象

代码示例

public class Singleton {
    // 1. 私有构造方法：禁止外部new对象
    private Singleton() {}

    // 2. 私有静态实例，volatile禁止指令重排
    private static volatile Singleton instance;

    // 3. 公共静态方法，获取唯一实例
    public static Singleton getInstance() {
        // 第一次校验：实例已存在就直接返回，不用抢锁
        if (instance == null) {
            // 加锁，保证线程安全
            synchronized (Singleton.class) {
                // 第二次校验：防止多线程同时进入第一个if，重复创建
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂方法模式

定义一个创建对象的工厂接口，让子类决定创建哪个对象，把对象的创建延迟到子类。

类比

就像奶茶店是工厂接口，蜜雪冰城、喜茶是子类工厂，你去哪个店，就喝哪个店的奶茶，不用管奶茶是怎么做的。

适用场景

不知道要创建的对象具体类型，交给子类决定
把对象创建和业务代码解耦
Spring的FactoryBean

代码示例

// 1. 产品接口：奶茶
public interface MilkTea {
    void make();
}

// 2. 具体产品：蜜雪冰城奶茶
public class MixueMilkTea implements MilkTea {
    @Override
    public void make() {
        System.out.println("蜜雪冰城奶茶做好了！");
    }
}

3. 抽象工厂模式

工厂方法的升级版，一个工厂可以创建一系列相关的产品，而不是只创建一个。

和工厂方法的区别是：

工厂方法是单个产品，而抽象工厂是一套相关产品。

类比

就像蜜雪冰城不仅能做奶茶，还能做冰淇淋、圣代，一个工厂搞定同品牌的一系列产品。

适用于需要创建一系列相关联的产品，而不是单个产品的场景（比如同一品牌的奶茶 + 冰淇淋 + 圣代）。

4. 建造者模式

把一个复杂对象的创建和表示分离，一步一步构建出复杂对象，不用管内部组装细节。

类比

就像组装电脑，你只需要告诉装机店你要什么 CPU、显卡、内存，装机店帮你一步步组装好，不用你自己焊主板。

适用场景

复杂对象的创建，参数特别多（比如超过4个参数）
Lombok的@Builder注解

代码示例

// 电脑类（复杂对象）
public class Computer {
    private String cpu;
    private String gpu;
    private int memory;
    private int storage;

    // 私有构造方法，只能通过Builder创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.memory = builder.memory;
        this.storage = builder.storage;
    }

    // 建造者静态内部类
    public static class Builder {
        private String cpu;
        private String gpu;
        private int memory;
        private int storage;

        // 链式调用设置参数
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Builder memory(int memory) {
            this.memory = memory;
            return this;
        }

        public Builder storage(int storage) {
            this.storage = storage;
            return this;
        }

        // 构建最终对象
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        // 链式调用，一步一步构建对象
        Computer computer = new Computer.Builder()
                .cpu("i7-14700K")
                .gpu("RTX4070")
                .memory(32)
                .storage(1024)
                .build();
    }
}

5. 原型模式

基于一个已有的对象，克隆出一个一模一样的新对象，不用重新new和初始化。

类比

就像打印机复印文件，不用重新手写一遍，直接复印一份一模一样的。

适用场景

对象创建成本很高（比如初始化要查数据库、调接口）
想要和原对象一模一样的新对象，又不想重新初始化
Spring的Bean的原型作用域

就像出行，你可以选骑自行车、坐地铁、开车、坐飞机，这些都是不同的出行策略，你可以根据目的地、预算随便换，不用改变你要出门的目标。

适用场景

一个业务有多种实现方式，需要动态切换
想要避免大量的if-else/switch分支
Spring的Resource接口、BeanNameGenerator

代码示例

// 1. 策略接口：出行方式
public interface TravelStrategy {
    void travel();
}

// 2. 具体策略：坐地铁
public class SubwayStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("坐地铁出行，便宜又快");
    }
}

// 3. 具体策略：开车
public class CarStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("开车出行，自由方便");
    }
}

// 4. 用户
public class Traveler {
    private TravelStrategy strategy;

    // 动态设置策略
    public void setStrategy(TravelStrategy strategy) {
        this.strategy = strategy;
    }

    // 执行出行
    public void goTravel() {
        strategy.travel();
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Traveler traveler = new Traveler();
        // 今天坐地铁
        traveler.setStrategy(new SubwayStrategy());
        traveler.goTravel();
        // 明天开车
        traveler.setStrategy(new CarStrategy());
        traveler.goTravel();
    }
}

2. 观察者模式

定义了对象之间一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并自动更新。

类比

就像你关注了一个CSDN博主，博主更新博客了，所有关注他的粉丝都会收到推送通知。

适用场景

事件驱动、消息通知、发布订阅
Spring的ApplicationEvent事件机制
Java的EventListener

适用场景

对象的行为由状态决定，运行时状态变化会改变行为
代码里有大量和状态相关的if-else/switch分支

小贴士

状态模式和策略模式容易混淆，不过两者的区别是：

状态模式是状态决定行为，对象的行为由当前状态决定；而策略模式是算法可替换，封装一系列平级算法，想换哪个换哪个。
状态模式有明确的状态流转图，状态之间不能随便跳，必须按规则流转；策略模式没有流转关系，策略之间是平级的，想换就换。
状态模式关注的是对象状态的变化以及状态变化带来的行为变化；策略模式关注的是算法的选择和替换，不关心算法之间的关系。

扯了那么多官话，好像没多大用，举个例子套一下大概就是：

比如电梯是状态模式，开门、上下行、关门有明确的流转规则；

撤销、回滚操作
数据库的事务回滚
IDE的撤销操作

10. 访问者模式

在不修改数据结构的前提下，定义对数据结构中元素的新操作，把数据结构和操作分离。

类比

比如电商订单系统，数据结构是固定的订单和订单明细，操作是经常变化的计算总价、打印发票、生成物流单、发送短信通知。不用修改订单 / 订单明细的代码，只要新增一个访问者（比如生成电子发票），就能给订单增加新操作。

适用于想要给数据结构里的元素增加新操作，又不想修改数据结构的场景。

11. 解释器模式

给定一个语言，定义它的语法规则，然后定义一个解释器，用这个解释器来解释语言中的句子。

类比

就像翻译官，你说中文，翻译官根据中英文的语法规则，把你的话翻译成英文。

适用场景

SQL解析、正则表达式解析
Spring的SpEL表达式

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

只有一个线程多次获取同一把锁，没有其他线程竞争。
第一个线程获取锁时，会在对象头的 Mark Word 里记录【偏向线程ID】，这个线程以后再次获取锁时，只需要检查偏向线程ID是不是自己，如果是，直接获取锁。
当有第二个线程来竞争这把锁时，偏向锁会撤销，升级为轻量级锁。

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

线程在自己的栈帧里创建一个锁记录（Lock Record），用 CAS（Compare And Swap，比较并交换）操作，尝试把对象头的 Mark Word 替换成指向自己栈中锁记录的指针。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Java字节流、字符流

Mon, 16 Mar 2026 10:00:59 +0000

Java IO流的分类

Java IO流主要从两个维度分类：

分类维度	分类结果	说明
按数据流向分	输入流（Input）	从磁盘/网络/内存「读」数据到程序
	输出流（Output）	从程序「写」数据到磁盘/网络/内存
按处理单元分	字节流（Byte Stream）	以「字节（byte）」为单位处理数据，是万能流
	字符流（Character Stream）	以「字符（char）」为单位处理数据，专门处理文本

字节流

什么是字节流？

计算机里所有数据（图片、视频、音频、文本、PDF）本质上都是字节（0和1的组合），所以字节流是万能流，可以处理任何类型的数据。

字节流的核心类

字节流的抽象基类是 InputStream（输入流）和 OutputStream（输出流），开发中最常用的是它们的子类：

类名	作用
`FileInputStream`	从文件中读取字节
`FileOutputStream`	向文件中写入字节
`BufferedInputStream`	带缓冲的字节输入流，提升读性能
`BufferedOutputStream`	带缓冲的字节输出流，提升写性能

举个例子

字节流典型的应用——复制非文本文件（图片、视频、PDF）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // 源文件路径（一张图片）
        String srcPath = "C:/test/photo.jpg";
        // 目标文件路径
        String destPath = "C:/test/photo_copy.jpg";

        // 用try-with-resources自动关闭流，避免内存泄漏
        try (
            // 1. 创建文件字节输入流：从源文件读字节
            FileInputStream fis = new FileInputStream(srcPath);
            // 2. 创建文件字节输出流：向目标文件写字节
            FileOutputStream fos = new FileOutputStream(destPath)
        ) {
            // 3. 定义一个字节数组作为缓冲区（一次读1024字节，即1KB，提升性能）
            byte[] buffer = new byte[1024];
            int len; // 记录每次实际读到的字节数

            // 4. 循环读写：fis.read(buffer)返回-1表示读到文件末尾
            while ((len = fis.read(buffer)) != -1) {
                // 只写实际读到的len个字节，避免最后一次写多余的空字节
                fos.write(buffer, 0, len);
            }
            System.out.println("图片复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

什么是字符流？

字符流是专门处理文本数据的流，它以【字符】为单位处理数据，内部会自动处理编码转换（比如把UTF-8编码的字节转成Java的char字符）。

为什么不用字节流处理文本？

因为中文等非ASCII字符占多个字节（比如UTF-8编码的中文占3个字节）。

如果用字节流读，可能会把一个汉字的3个字节截断，从而导致乱码；

而字符流会自动识别编码，按字符读取，不会乱码。

字符流的核心类

字符流的抽象基类是 Reader（输入流）和 Writer（输出流），开发中最常用的是它们的子类：

类名	作用
`FileReader`	从文件中读取字符
`FileWriter`	向文件中写入字符
`BufferedReader`	带缓冲的字符输入流
`BufferedWriter`	带缓冲的字符输出流
`InputStreamReader`	转换流：字节流转字符流
`OutputStreamWriter`	转换流：字符流转字节流

举个例子

BufferedReader的readLine()方法可以按行读取文本，非常方便。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class CharacterStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/test/中文文章.txt";

        // 用转换流InputStreamReader，显式指定UTF-8编码，避免乱码
        try (
            // 1. 先创建字节输入流
            FileInputStream fis = new FileInputStream(filePath);
            // 2. 用转换流把字节流转成字符流，显式指定UTF-8编码
            InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
            // 3. 用缓冲流包装，提升性能，且有readLine()方法
            BufferedReader br = new BufferedReader(isr)
        ) {
            String line;
            int lineNum = 1;
            // readLine()返回null表示读到文件末尾
            while ((line = br.readLine()) != null) {
                System.out.println("第" + lineNum + "行：" + line);
                lineNum++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Windows 环境下 OpenClaw 的安装与千问大模型配置

Fri, 20 Feb 2026 16:53:53 +0000

为了不占用 C 盘空间，重装系统也不丢失配置，本文详细记录了如何将 OpenClaw 安装在非系统盘，比如D 盘，并对接阿里云通义千问大模型的全过程。

主要是利用 NVM 和 npm 进行安装，方便后续一键升级，配置具有免费额度的Qwen API，这个只需要在阿里云百炼注册一个账号就能获得免费额度。

准备工作

1.在安装之前，在D盘创建以下目录：

1
2

D:\SOFT_WARE\OpenClaw\data：用于存放配置文件、日志和数据库。
D:\SOFT_WARE\OpenClaw\workspace：用于存放 AI 生成的代码和项目。

2.配置环境变量
新建系统环境变量：OPENCLAW_HOME = D:\SOFT_WARE\OpenClaw\data
这个操作的目的是将原本在 C:\Users\用户名.openclaw 的配置转移到 D 盘。

3.安装 NVM和npm

下载地址：https://github.com/coreybutler/nvm-windows/releases

安装后配置 NVM 路径：

`1`	`nvm root D:\SOFT_WARE\NVM`

安装满足要求的 Node 版本：

nvm install 22.12.0  
nvm use 22.12.0      # 切换到该版本
node -v  # 验证 Node 版本（显示 v22.12.0 则表示成功）
npm -v   # 验证 npm 可用

安装步骤

以管理员权限打开 PowerShell，执行：

`1`	`npm install -g openclaw`

验证安装的版本：

`1`	`openclaw -v`

配置 Qwen 大模型

以管理员权限打开 PowerShell，执行：

`1`	`[Environment]::SetEnvironmentVariable("DASHSCOPE_API_KEY", "你的sk-xxx密钥", "User")`

修改 D:\SOFT_WARE\OpenClaw\data.openclaw\openclaw.json 文件。

{
  "meta": {
    "lastTouchedVersion": "2026.2.19-2",
    "lastTouchedAt": "2026-02-20T04:31:04.294Z"
  },
  "wizard": {
    "lastRunAt": "2026-02-20T03:22:24.306Z",
    "lastRunVersion": "2026.2.19-2",
    "lastRunCommand": "configure",
    "lastRunMode": "local"
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "bailian/qwen3.5-plus-2026-02-15"
      },
      "models": {
        "bailian/qwen3.5-plus-2026-02-15": {
          "alias": "通义千问3.5 Plus"
        },
        "bailian/qwen3.5-plus": {
          "alias": "通义千问 Plus"
        }
      },
      "workspace": "D:\\SOFT_WARE\\OpenClaw\\workspace",
      "compaction": {
        "mode": "safeguard"
      },
      "maxConcurrent": 4,
      "subagents": {
        "maxConcurrent": 8
      }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "bailian": {
        "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "apiKey": "${DASHSCOPE_API_KEY}",
        "api": "openai-completions",
        "models": [
          {
            "id": "qwen3.5-plus-2026-02-15",
            "name": "通义千问3.5 Plus",
            "reasoning": false,
            "input": ["text"],
            "cost": {
              "input": 0.0025,
              "output": 0.01
            },
            "contextWindow": 262144,
            "maxTokens": 65536
          },
          {
            "id": "qwen3.5-plus",
            "name": "通义千问3.5 Plus",
            "reasoning": false,
            "input": ["text"],
            "cost": {
              "input": 0.008,
              "output": 0.008
            },
            "contextWindow": 1029000,
            "maxTokens": 32000
          }
        ]
      }
    }
  },
  "tools": {
    "web": {
      "search": { "enabled": true },
      "fetch": { "enabled": true }
    }
  },
  "gateway": {
    "port": 12345,
    "mode": "local",
    "bind": "loopback",
    "auth": {
      "mode": "token",
      "token": "你的自定义Token"
    }
  },
  "commands": {
    "native": "auto",
    "nativeSkills": "auto",
    "restart": true
  }
}

启动网关服务

OpenClaw 依靠网关（Gateway）提供网页交互界面。以管理员权限打开 PowerShell，执行：

1
2

openclaw gateway install --force  # 加 --force 避免残留配置冲突
openclaw gateway start

网页端使用与登录

在命令行输入

`1`	`openclaw config get gateway.auth.token`

获取登录 Token或者直接从 JSON 中复制。

打开浏览器访问 http://127.0.0.1:你的端口号

小贴士

1.Windows 路径在 JSON 中必须使用双反斜杠 \。
2.浏览器的无痕模式会丢失本地缓存，可能会导致每次刷新页面都要重新输入 Token。
http://127.0.0.1:你的端口号/?token=你的TOKEN

修改 openclaw.json 后需重启网关（openclaw gateway restart）才能生效；
升级 OpenClaw：npm update -g openclaw;

5.卸载网关：openclaw gateway uninstall --force。

6."port": 你的端口号 ➡️ 填写纯数字（如 12345）；

7."token": "你的自定义Token" ➡️ 填写任意字符串（如 openclaw_123456）

AI 浪潮下，工具的配置是第一步。希望这篇笔记能帮大家在 Windows 平台上少走弯路！

说说MCP的工作流程

Wed, 21 Jan 2026 17:29:21 +0000

1.首先主机应用程序启动并初始化MCP客户端，每个客户端与一个MCP服务器建立专属连接，确保通信链路的稳定性与安全性。

2.在系统初始化阶段，MCP Client首先从MCP Server获取可用的工具清单和能力描述，让模型知道有哪些可以调用的外部技能。

3.当用户输入一个问题后，MCP Client会将这些工具描述采用Function Calling格式传给LLM，让模型具备调用外部工具的能力。

4.LLM根据当前对话的上下文、用户问题意图以及工具能力描述，判断是否需要使用外部工具，并决定调用哪一个工具、传入什么参数。

5.如果模型发起调用请求，MCP Client会根据模型的选择，通过MCP Server发起标准化的工具调用请求，由MCP Server执行实际工具逻辑后，将结果返回给MCP Client。

6.当工具的执行结果被传回LLM后，由模型将这个结果与原始用户问题以及已有的上下文等信息进行整合，生成符合用户需求的自然语言回应。

7.最后，MCP Client将模型生成的回答展示给用户。

MCP协议的安全性设计包含哪些层面？

Tue, 20 Jan 2026 15:43:02 +0000

MCP协议的安全性设计主要是为了确保大模型系统在与外部工具和资源进行交互时的安全性和可靠性。

主要包含用户同意和控制、隔离与沙箱机制、加密传输与来源验证这3个层面。

1.所有模型对工具、资源和提示的访问请求都必须经过用户的授权，用户必须知道哪些数据是需要提供给大模型的，在授权之前应该了解每个工具的功能。

2.MCP将实际工具调用封装在MCP Server内部，模型本身无法直接访问敏感数据；沙箱机制对工具调用的执行环境进行限制，防止恶意操作对系统的破坏。

3.MCP内置的安全机制确保只有经过了验证的请求才能访问特定的资源，另外MCP协议还支持多种加密算法。

怎么将已有的应用转换成MCP服务

Mon, 19 Jan 2026 16:38:18 +0000

将已有的应用转换为MCP（Model Context Protocol）服务需要将该应用的功能封装为标准化的MCP工具、资源或者提示，再通过MCP Server对外暴露。

主要步骤如下：

1.首先需要识别应用中要提供给外部调用的功能，比如说API接口、数据查询、业务计算、资源检索这类能力。

2.再创建一个新的MCP服务，将其与已有的业务服务隔离开，通过标准化的内部API或SDK和业务服务进行解耦通信。

3.对MCP服务需要包含的工具功能描述、方法入参字段、类型、描述，以及方法返回值的字段、类型、描述进行标准化定义。

4.根据MCP协议规范，构建一个用于接收MCP 客户端请求、做标准化协议解析与参数校验、调用相应业务功能并返回标准化结果的MCP Server。

大模型的微调和预训练区别是什么

Mon, 19 Jan 2026 16:12:13 +0000

大模型微调（Fine-tuning of Large Models）是指在预训练（Pre-training）模型的基础上，使用特定任务的数据对模型进行再训练，使模型适应特定应用场景的需求，本质上就是迁移学习在大模型中的落地方式。

微调和预训练的区别主要在于目标、数据来源和训练方式。

1.预训练通常是在大规模通用数据集上进行训练，让模型学习通用的语言规律或者知识；而微调通常是在特定任务的数据集上进行训练，让模型适应特定的任务。

2.预训练通常采用的是无监督或者自监督学习的方式，而微调通常采用的是监督学习的方式。

微调在自然语言处理中的文本分类、命名实体识别以及计算机视觉中的图像分类、目标检测都有广泛的应用。

说说大模型中的PEFT

Sun, 18 Jan 2026 16:51:50 +0000

PEFT（Parameter Efficient Fine Tuning）参数高效微调是一种在微调预训练大模型时，只对适配器模块、低秩增量矩阵和提示嵌入这些少量的新增参数进行训练，并对原始模型的大部分权重进行冻结的策略。

PEFT能够在计算和存储成本大幅度降低的前提下，仍然能够保持与全量微调相近的性能。

那什么要有这样一种微调方法呢？

主要是全量微调对显存、算力以及存储的要求都非常高，并且迭代速度很慢，不利于多任务和在线更新；

如果是在小样本场景下还容易出现过拟合问题。

而我们的PEFT可以通过只更新数百万级别或者更少的参数，就能好实现高效微调和快速迭代。

PEFT的主要优势是：

1.PEFT方法能够将可训练参数比例控制在0.1%~5%之间，能够显著地节省计算资源和存储空间。

2.少量的可训练参数往往意味着反向传播与梯度更新的计算量大幅度下降，训练时间也能够缩短数倍，这样就能加快训练的收敛速度。

3.由于PEFT保留了预训练阶段学习到的通用知识，因此在数据稀缺或者小样本环境下，还能够降低过拟合的风险。

4.PEFT生成的Adapter、LoRA和Prefix这些增量模块可以和基础模型分离存储，这样不同的任务只需要加载对应的模块。

大模型中常见的微调方法

Sun, 18 Jan 2026 16:26:29 +0000

Fine-tuning大模型微调指的是在预训练模型的基础上，使用特定的数据对模型进行再训练，以适应特定应用场景的需求。

常见的微调方法分为全量微调、参数高效微调以及量化与混合微调这三类。

全量微调

全量微调是直接对预训练模型中的所有参数进行再训练，使模型适应特定任务或者领域的需求，这种方式可以获得最佳的任务性能，不过缺点也很明显，因为是对所有参数再次训练，所以计算和存储的开销极大。

参数高效微调（Parameter-Efficient Fine-tuning，PEFT）

参数高效微调只更新少量的参数，从而大幅度降低训练和存储的成本。

有以下6种方法：

Adapter Tuning 是在Transformer`每层中插入小模块，只训练Adapter。
LoRA（Low Rank Adaptation）为每层添加低秩分解矩阵，然后只对这些矩阵进行训练，是目前最流行的一种PEFT方法。
Prefix Tuning在输入前加入可训练的prefix tokens，模型本体权重完全冻结。
Prompt Tuning只训练用于任务提示的嵌入向量，不改变模型的内部结构，以提示的形式引导模型的行为。
P-Tuning通过可学习的伪提示目标来优化。
BitFit只更新bias参数，训练参数占比通常小于0.1%。

量化与混合微调

QLoRA结合了4-bit量化、LoRA、双量化和分页优化器，利用低精度存储与低秩适配，单卡就能对百亿级模型进行微调。

IR -QLoRA在量化阶段引入信息保留机制与弹性联结，进一步减少了量化带来的性能损耗。

常见的微调任务

Sat, 17 Jan 2026 18:16:33 +0000

大模型微调（Fine-tuning）是指在预训练模型的基础上，使用特定任务的数据对模型进行再训练，以适应特定应用场景的需求。

在实际的应用中，可以采取全模型微调、部分微调、参数高效微调等不同的策略，以适应不同的场景。

常见的微调任务主要🈶️以下几类：

1.将文本分为不同的类别

2.识别文本中的人名、地名等实体

3.根据指定的问题，从文本总寻找答案

4.生成摘要、段落总结等于输入相关的文本

5.将某种语言的文本翻译成另外一种语言

6.处理图文匹配、生成图像描述等多种类型的数据

MCP协议在大模型中的作用

Sat, 17 Jan 2026 18:15:49 +0000

MCP（Model Context Protocol）模型上下文协议，主要是为大语言模型和AI助手提供一个统一的标准化接口，突破了模型对静态知识库的依赖，使其具备了更强的动态交互能力。

像数据库、API等其他服务，只要是通过MCP接入，大语言模型都能理解并利用这些资源，从而扩展其功能和应用范围。

MCP主要由以下3个方面的作用：

1.MCP提供了统一的协议接口，可以实现一次集成，随处连接，简化了模型与外部系统的集成过程。

2.MCP能够使模型实时地访问最新的数据和工具。

3.MCP使得系统的各个组件可以更加模块化地协作，从而降低了系统的维护成本和出错概率。

MCP架构包含哪些核心组件

Fri, 16 Jan 2026 16:28:50 +0000

包含MCP主机、MCP客户端、MCP服务器、本地数据源和远程服务五大核心组件。

MCP 主机是希望通过MCP访问数据的程序。

MCP Server主要负责向 LLM 提供结构化上下文和可调用的操作能力。

MCP Server定义了资源、工具、提示三大类基础功能，这三类能力为语言模型提供了更强的上下文输入和交互能力。

MCP服务器可以安全地访问用户的计算机文件、数据库和服务这些本地数据源。

MCP服务器可以通过API连接到外部的系统。

MCP客户端是连接大语言模型与MCP服务器的桥梁，负责在模型与外部工具之间传递信息和协调操作。

说说你了解的向量数据库

Fri, 16 Jan 2026 16:27:12 +0000

主流的向量数据库有Milvus、Pinecone、Weaviate、Qdrant、Chroma等。

1. Milvus

支持TB级向量的增删改操作，以及近实时查询；

适合推荐系统、图像检索、NLP等场景。

2.Pinecone

开箱即用，高并发性能好；

适合实时搜索、快速原型开发等场景；

缺点是按使用量计费，使用成本较高；

3.Weaviate

支持文本和图像等多模态数据；

适合知识图谱和智能问答场景；

缺点是复杂查询时的延迟较高；

4.Qdrant

支持向量与元数据联合搜索；

适合推荐系统中元数据与向量结合的复杂查询；

5.Chroma

专注嵌入式向量存储，支持本地化部署；

适合中小规模数据；

解释一下向量数据库中的HNSW、LSH和PQ

Thu, 15 Jan 2026 17:53:06 +0000

HNSW、LSH和PQ是向量数据库中的3种核心索引与压缩技术，用于加速高维向量的相似性搜索。

HNSW

Hierarchical Navigable Small World（HNSW），在高维空间中，构建多层图结构，每一层都是一个小世界网络。

上层的节点比较稀疏，能快速跳跃式定位大致的范围；

下层的节点比较密集，用于精细搜索。

HNSW技术查询速度和精度的平衡比较优秀。

LSH

Locality-Sensitive Hashing（LSH），是由经过特殊设计的哈希函数，能够使相似向量以较高的概率映射到同一个哈希桶，不相似的向量尽量分散到不同的哈希桶。

在查询的时候，只需要搜索查询向量所在的哈希桶以及相邻的哈希桶，极大地缩小了检索范围。

LSH技术在推荐系统、图像检索等海量数据的近似查询场景中应用广泛。

PQ

Product Quantization（PQ）将高维的向量拆分成多个低维的子向量，对每个子向量集合进行聚类，生成聚类中心。

在存储的时候，用聚类中心的编号表示向量，从而大幅减少存储空间。

PQ技术常用于工业级的向量检索系统。

说说Copilot模式和Agent模式的区别

Thu, 15 Jan 2026 17:32:27 +0000

Copilot模式（副驾驶协助模式）是大模型作为“助手”提供实时的建议，比如代码补全、文案的润色等等，最终的决策权保留在用户手中

Agent模式（代理智能体模式）是可以自主驱动，大模型可以独立的拆解任务、调用工具完成端到端的操作。

除了这两个模式之外，还有一个Embedding模式（嵌入模式），这个模式主要是在后台进行辅助，将大模型作为一个隐藏的组件集成到现有的系统中，这种模式用户是无法感知的。

Embedding模式有很多的实际应用的例子，比如在推荐系统中，电商平台用Embedding理解商品和用户的兴趣，但是用户往往只能看到“猜你喜欢”。

说说Computer-Use的原理

Thu, 15 Jan 2026 16:54:17 +0000

Computer Use是让Claude能够操作计算机。

实际工作原理：

Claude通过截图观察屏幕的内容，基于视觉理解，Claude计算出需要点击或者输入的像素坐标，通过API发送鼠标移动、点击和键盘输入等指令，执行操作后再次截图，观察结果并决定下一步。

Computer Use场景：

在网页表单中填写信息并提交
执行需要多个软件协同的复杂工作流
操作如PS、PPT、Excel等桌面应用程序

说说你对Manus的了解

Thu, 15 Jan 2026 15:50:33 +0000

Manus是由Monica.im团队于2025年3月推出的全球首款通用型AI智能体，它的重大突破在于能够独立思考、规划并执行复杂的任务，可以直接交付诸如股票分析结果、简历筛选结果这些完整的成果。

Manus主要是通过一个中央模块，将用户的指令拆解为多个子任务，再通过不同的内部智能体或者工具执行，形成端到端的自动化执行流程。

Manus的底层还是调用了诸如Claude、ChatGPT这些大模型来实现规划和决策。

Manus的执行过程可以分为4个主要阶段：

1.规划器

基于LLM生成总体执行计划，并拆分子任务。

2.智能体/工具

每个子任务可以由不同的模型或者外部的API完成。

3.状态驱动和条件分支

执行过程中根据中间结果动态地决定是否需要重试、是否需要切换方案或者是否需要提前结束。

4.可回溯和异步执行

可记录全过程的执行“Trace”，可在Web控制台进行Debug，也支持后台的长期运行。

LangChain和LangGraph两者有什么区别

Wed, 14 Jan 2026 15:52:28 +0000

LangChain是基于链式结构的，像一个用于拼接模型、工具和记忆等组件的模块化AI应用框架，通过预定义步骤顺序执行，适合处理文档问答、简单客服这类线性任务。

LangGraph是基于图结构的，像一个专注于流程控制和任务编排的有状态执行图框架，支持循环、分支和动态决策，适合临床试验审批、多智能体投资分析这类需要多角色协作、状态跟踪的复杂任务。

在实际的开发过程中，一般简单任务用LangChain，复杂任务用LangGraph，对于特别复杂的任务则会考虑对这两者进行结合使用。

提示词的优化需要考虑哪些维度

Wed, 14 Jan 2026 15:06:27 +0000

提示词的优化需要考虑以下5个维度：

1.让模型清楚地知道要解决的是什么问题（目标明确）

2.用分点、markdown/JSON/分隔符拆解任务，使提示词的结构更清晰（结构清晰）

3.通过少量的输入输出样例告诉模型用户实际期望的结果到底长什么样，避免理解上的偏差（少量样本）

4.给模型定义一个身份，让模型的输出风格更加符合实际的场景（角色）

5.限制模型的输出范围，对字数、格式以及禁止的内容进行限定，避免模型出现幻觉（增加约束条件）

提示词模板中的常见字段：

角色定义	指定模型的身份
任务描述	用具体的指令多目标进行拆解
输入内容	提供原始数据或者问题案例
输出格式	规定结果的格式，比如输出markdown格式
约束规则	说明限制条件，比如回答不超过多少个字
评估标准	引导模型自检

怎么优化RAG的检索效果

Tue, 13 Jan 2026 16:06:35 +0000

主要可以从以下几个方面考虑：

1.保证知识库中的原始文档内容准确、结构清晰、格式规范，尽量减少水印、不相关图片等噪音。

2.由于过小的切片可能会导致语义不完整，过大的切片又可能会引入过多的无关信息，因此，需要采用合适的文档切片策略，避免固定的长度切分导致语义断裂。

3.为了后续进行更精准地过滤和检索，可以考虑对文档切片添加来源、日期、类别、标签等元数据。

4.使用大模型把用户的原始查询改写得更清晰、详细和规范一些，这样可以提高后续检索的准确性。

5.像关键词检索和向量检索都有不同的优势，可以将两者进行结合，比如先用向量检索召回语义相关的文档，然后再使用关键词检索进行精确匹配。

怎么实现AI的多轮对话功能

Tue, 13 Jan 2026 15:49:02 +0000

要实现AI的多轮对话功能，关键在于让AI能够记住与用户之前的对话内容并保持上下文的连贯。

可以使用Spring AI框架提供的对话记忆和Advisor特性来实现这个功能。

主要是通过构造ChatClient来实现功能更丰富、更灵活的AI对话。

ChatClient可以看成是一系列可插拔的拦截器，在调用AI前后执行一些额外的操作。

MessageChatMemoryAdvisor是实现多轮对话的关键Advisor，其主要作用就是从对话记忆中检索历史对话，然后将对话历史作为消息集合添加到当前的提示词中，这样的话，AI模型就可以记住之前进行过的交流。

ChatMemory接口中定义了保存消息、查询消息和清空历史的方法，MessageChatMemoryAdvisor也依赖于这个接口的实现来存取对话历史。

为了解决对话记忆仅存在于内存中，在服务重启之后会造成记忆丢失的问题，需要考虑将对话记忆进行持久化。

由于spring-ai-starter-model-chat-memory-jdbc的依赖版本较少，可以考虑自定义ChatMemory接口的方式实现：

开发一个实现了ChatMemory接口的FileBasedChatMemory类，再使用高性能的Kryo序列化库将对话消息序列化后保存到本地文件中，读取的时候再进行反序列化。

怎么分析LLM在并发访问时的性能瓶颈

Tue, 13 Jan 2026 15:28:15 +0000

试想一下这样一种场景：

如果一个GPU集群的LLM处理能力为1000 tokens/s，那么1000个用户同时并发访问的话，响应给每个用户的性能只有 1 token/s吗？

肯定不是。

因为LLM并不是简单的线性分配资源，而是通过批处理与并发调度的方式来提升吞吐量的。

LLM的核心计算是矩阵乘法，GPU的并行计算特性让“批量处理多个用户的tokens”耗时几乎不会增加，能充分地利用硬件资源。

如果每一次批处理包含100个用户请求，每个用户10个tokens，那么1000个用户可以分10批处理完，当用户的性能是10 tokens/s。

实际响应的速度取决于以下关键因素：

Token的长度：输入Token影响批处理耗时，输出Token影响总响应时间，流式输出可以优化体感延迟；
批处理策略：静态批处理简单并且易实现，动态批处理资源的利用率更高，连续批处理可以支撑超高并发；
资源排队机制：FIFO、优先级队列等等策略决定请求的等待时间，不影响最终的处理速度。

Spring-AI怎么实现结构化输出

Mon, 12 Jan 2026 16:12:09 +0000

结构化输出是将大语言模型返回的自由文本输出转换为预定义的数据格式。

Spring AI是通过StructuredOutputConverter机制来实现结构化输出的：

1.StructuredOutputConverter实现了FormatProvider接口，这个接口提供特定的格式指令给AI模型，这些指令附加到用户的提示词后面，明确地告诉模型应该生成何种结构的输出。

2.StructuredOutputConverter 实现了Spring的Converter<String, T>接口，这个接口负责将大模型返回的文本输出转换为开发者指定的目标类型。

Spring AI提供了多种内置的转换器实现：

BeanOutputConverter：转换为自定义Java实体类，在开发中最常用；

MapOutputConverter：转换为松散的Map键值对结构；

ListOutputConverter：转换为指定类型的集合结构。

解释一下Re-Reading

Mon, 12 Jan 2026 15:32:15 +0000

Re-Reading（重读），是一种通过让大语言模型重新阅读问题来提高其推理能力的技术。

有文献研究证明：

对于复杂的问题，重复阅读和审视问题有助于模型更好地理解题意和约束，从而能够生成更准确、更深入的回答。

在Spring AI中，可以通过自定义Advisor来实现Re-Reading功能：

1.创建自定义Advisor类，同时实现用于同步请求的CallAroundAdvisor接口和用于流式请求的StreamAroundAdvisor接口，实现后可以兼容所有大模型调用场景。

2.在Advisor的前置处理逻辑中，对用户的原始输入文本进行重读式Prompt增强改写。

3.将改写后的提示词传递给大语言模型进行处理。

介绍一下Spring-AI框架

Sun, 11 Jan 2026 15:43:59 +0000

Spring AI是一个基于Spring生态的AI应用开发框架。

通过提供统一的API和抽象，让Java开发者可以不用考虑底层实现的差异，更便捷地接入和使用各种AI大模型及其相关技术。

Spring AI框架的核心特性：

1.为聊天、文本转图像和嵌入模型提供统一的API，支持流式调用和同步，支持访问特定模型的功能。

2.支持OpenAI、微软Azure、Google、Ollama在内的主流AI模型供应商。

3.可以实现将AI模型的输出自动映射到POJO，方便在Java应用中处理。

4.支持与多种主流向量数据库的集成，通过跨向量存储的可移植API。

5.支持模型请求执行客户端定义的函数和工具。

6.提供文档抽取、转换和加载的组件，可用于数据工程和RAG知识库的构建。

7.为AI模型和向量存储提供了自动配置和Starter依赖。

8.提供类似于WebClient和RestClient的流式API，便于与AI模型交互。

9.提供标准化的Prompt模板引擎，支持动态参数填充和模板复用。

LangGraph的编排原理

Sun, 11 Jan 2026 14:57:27 +0000

LangGraph的编排原理是通过图结构将一个复杂的AI任务分解为可编排的节点，通过状态流转和条件边实现动态流程控制。

有节点、边、状态三个核心要素：

1.节点代表独立处理单元，每个节点负责接收状态并返回更新后的状态。

2.边定义节点间的流转路径，支持条件分支和循环。

3.状态贯穿整个流程的上下文数据，驱动节点间的动态交互。

通过画图描述逻辑任务，框架自动根据状态流转执行节点，支持复杂的多Agent协作和动态决策。

说说LangChain的核心架构

Sat, 10 Jan 2026 15:22:25 +0000

LangChain的核心架构主要由LangChain Libraries、LangChain Templates、LangServe和LangSmith四个模块组成。

LangChain Libraries

整个LangChain框架的基础，包含langchain-core、langchain以及langchain-community三个子模块。

其中，langchain-core提供了构建应用所需的核心功能；

langchain是构建链和代理的主要模块；

langchain-community整合了多个第三方库和集成。

LangChain Templates

提供了一系列适用于各种任务的参考架构模板，像问答系统、文档解析和对话管理等常见的任务。

LangServe

用于将LangChain构建的链部署为REST API的库，支持高并发请求和流式操作，适用于构建生产环境中的API服务。

LangSmith

这是一个开发者平台，提供调试、测试、评估和监控的功能。

LangChain有哪些核心组件

Sat, 10 Jan 2026 14:45:10 +0000

LangChain是一个专为大语言模型应用开发而设计的框架。

主要有以下6个核心组件：

1.模型集成。支持OpenAI、Anthropic、Llama等多种语言模型，提供了统一的接口，可以在不同模型之间切换。

2.提示词模板。通过模板化的方式，根据不同的输入生成相应的提示词，引导模型生成更加准确的输出。

3.记忆机制。通过存储对话的上下文信息，使得LangChain能够在多轮对话中保持上下文的一致性，提升模型的响应质量。

4.链式调用。将多个处理步骤串联起来，形成一个处理流程，使复杂任务的处理更加模块化和可复用。

5.智能体。Agent可以根据用户的输入动态地选择合适的工具来完成任务，实现更加灵活的任务处理。

6.工具集成。集成各种外部工具，提供访问外部资源的能力，扩展了模型的功能，使其能够处理更复杂的任务。

解释一下Selector、Channel

Fri, 09 Jan 2026 14:15:00 +0000

Selector

Selector是Java Non-blocking I/O中用于实现I/O多路复用的组件。

Selector有4种事件类型，分别是：

OP_READ	表示通道中有数据可读
OP_WRITE	表示可以向通道中写入数据
OP_CONNECT	表示通道完成连接操作
OP_ACCEPT	表示通道可以接受新的连接

Selector的作用有两个：

一个是通过一个Selector实例，程序可以同时监听多个通道的I/O事件。

另一个是Selector通常与非阻塞通道配合使用，可以实现高效地非阻塞I/O操作。

Channel

Channel是Java Non-blocking I/O中的一个核心概念，主要用于数据的读写操作。

Channel有四种类型：

SocketChannel	用于基于TCP的网络通信，可以与服务器或者客户端进行连接
ServerSocketChannel	仅用于TCP服务端，用于监听TCP连接
DatagramChannel	用于基于UDP的网络通信
FileChannel	用于从文件中读取或者向文件中写入数据

Channel是双向的，可以同时支持读取和写入。

传统的流要么是输入流，要么是输出流，只能是单向的。

因此，Channel比传统的I/O流更灵活和高效。

Channel可以结合Selector实现多路复用，从而处理多个并发连接。

大模型的结构化输出是什么

Fri, 09 Jan 2026 13:00:00 +0000

结构化输出是让大模型生成符合特定格式的数据，而不是自由文本。

其中，特定的格式可以是JSON、XML、表格等等。

这样的输出可以被计算机程序直接解析和处理。

常见的数据格式有：JSON、YAML、CSV、XML

常见的结构化文本有：表格、键值对

还有某些领域的特定格式，比如：SQL语句、HTML、LaTeX

要实现这样的结构化输出，需要在输入提示中明确要求输出格式，并用代码解析模型生成的文本，转换为标准结构，然后使用库或者框架自动验证和解析输出格式。

在RAG应用中-有哪些提示工程设计技巧

Thu, 08 Jan 2026 15:12:58 +0000

提示工程的设计技巧主要有：

1.提示中需要清楚地说明AI的身份、能力边界和目标任务。

2.需要用明确的格式指导AI输出。

3.明确告知AI只能基于检索到的资料进行回答，以免出现“幻觉”。

4.可以将提示设计成模板，预留动态的填充位，方便大规模复用和动态地填充检索内容。

5.如果没有检索到相关的内容，不要使用模型自身的知识储备进行推断，直接让AI显示地回复“未找到相关的资料”。

6.可以给1到2个优质的问答范例，让模型模仿输出风格和逻辑。

在RAG中选择Embedding-Model需要考虑哪些因素

Wed, 07 Jan 2026 14:43:53 +0000

在RAG中选择Embedding Model时，主要考虑的是以下7大因素：

1.模型能否精准地捕捉文本语义，准确性直接影响到向量相似度计算的可靠性。（语义准确性）

2.模型的推理速度能否满足业务的实时性要求，显存和内存的占用能否适配当下的硬件资源。（模型的效率）

3.是否专门针对某个垂直领域做过预训练或者微调，原生支持特定术语和逻辑。（领域适配）

4.是否支持业务所需的语言，以及具备跨语言对齐能力。（多语言支持）

5.模型的参数量和训练数据规模是否匹配语料的复杂度。（数据规模匹配）

6.是否开源、是否有活跃的社区在维护，API的调用是否灵活。（开放性与生态）

7.训练和推理的硬件投入成本以及使用成本。（成本）

说说RAG中的Embedding嵌入

Tue, 06 Jan 2026 15:43:40 +0000

把文本内容、图像、音频、视频等形式的信息映射为高维空间中的密集向量的过程就是“嵌入”。

向量是语义空间中的坐标，主要用于捕捉对象之间的语义关系和隐含的意义。

每个向量相当于文本的数字指纹，里面包含了文本的语义信息。

一般来说，语义相近的对象在向量空间中彼此接近，语义相异的对象则彼此远离。

在向量空间中进行数学计算可以判断两段话是否相关。

分块后的文本块需要先生成Embedding，存入到向量数据库中，在用户提问时，系统通过计算提问的Embedding 与文本块的Embeding之间的相似度，找到和用户的提问最相关的内容，再交给大模型生成回答。

那为什么需要Embedding呢？

主要是因为传统的检索比较依赖关键词匹配，难以应对同义词、上下文和多样化表达的问题。

Embedding是将文本映射到高维的向量空间，如果用户问“怎么泡咖啡”，经过Embedding之后可以将“咖啡的制作步骤”等语义相关的概念通过向量距离自动匹配。

为什么在RAG中需要提示压缩

Mon, 05 Jan 2026 14:11:44 +0000

在RAG（检索增强生成）中，提示压缩主要是对检索出的文档内容通过提取核心信息、过滤无关文本、压缩冗长内容的方式进行精简处理，使得最终输入给大模型的内容既能够保留关键的信息，又符合模型输入长度的限制。

那为什么要这么做呢？

因为RAG的生成效果十分依赖“输入给模型的文档质量”。

1.如果直接将大量拼接的检索内容输入给大模型，很可能会超出大模型的输入长度限制，而通过压缩可以将关键的信息浓缩进有限的token内。

2.检索出的文档中很有可能包含大量的无关内容，这些内容往往会稀释关键信息，最终导致大模型聚焦困难，抓不住重点，如果不经过压缩生成的回答可能出现偏差，甚至出现“幻觉”。

3.如果输入的文档存在较多的非必要内容，不经过压缩将增加模型处理和推理的计算负担，像商业的大模型都是通过token来计费的，因此还可能增加成本。

A2A协议和MCP协议的关系

Mon, 05 Jan 2026 13:34:53 +0000

在AI生态系统中，A2A协议和MCP协议是两个扮演着不同角色但是又互补的标准协议。

A2A（Agent to Agent）协议是一个应用层协议，允许不同的AI智能体以“智能体”或者“用户”的身份进行交流，更关注智能体之间的沟通和协作。

MCP（Model Context Protocol）协议则提供了AI模型与外部的数据源和工具的标准化连接方式，允许AI模型通过统一的接口访问文件、数据库、API等资源。

A2A类似于一个电话簿，目的是让不同的AI智能体可以相互联系和协作；

而MCP则类似于一个工具说明书，主要是为了告诉AI模型怎么使用外部的工具和数据。

解释一下什么是查询拓展

Sun, 04 Jan 2026 15:03:51 +0000

查询拓展是指对用户的原始查询通过添加同义词、相关术语、隐含意图等信息的方式进行优化和补充，使得查询更加精准、覆盖范围更广，从而提升信息检索的效果。

接下来说说为什么在RAG中需要进行查询扩展？

如果原始查询不够准确或者覆盖范围不足，就会导致检索到的文档不相关或者信息不全，最终导致生成的回答质量会受到影响。

如果增加了查询扩展，当用户的用词和知识库中的术语不一致时，可以在扩展后匹配更多的相关内容；

还有就是用户的查询中的描述可能会比较简短或者模糊不清，这样在扩展后能够更加明确需求，使得检索更加精准。

说说混合检索

Sat, 03 Jan 2026 14:31:43 +0000

混合检索主要是为了提升大模型的上下文理解和回答的准确性，

因为向量检索更擅长语义的理解，但是对于一些专有名词就难以做到精准匹配。

而关键词检索的特性和向量检索相反，二者正好形成了互补优势，将两者结合能够大幅的提升检索结果的全面性和准确性。

在大模型RAG应用中，混合检索主要通过向量检索将文本转化为高维向量，计算语义的相似度，同时并行基于倒排索引算法等关键词检索来精准地匹配关键词，最后将两种结果通过权重的融合或者重排序模型进行合并，最终输出最优的答案。

说说A2A协议的5大设计原则

Fri, 02 Jan 2026 14:25:49 +0000

A2A（Agent2Agent）协议是为了打破现阶段各个Agent框架之间的隔离，让它们可以实现无障碍地交流而提出的一种AI智能体界的普通话标准。

A2A协议遵循5大设计原则：

1.传统的API是我调用你一下，你就响应一下。但A2A是把Agent当人看，而不是当工具来用。它允许Agent之间像同事一样进行协作，它们可以自己商量怎么完成任务。（自主性）

2.A2A协议是建立在现有标准之上的，底层用的是HTTP、SSE、JSON-RPC这些成熟的技术，所以企业现有的IT系统可以直接接入。（标准化）

3.A2A集成了企业级的身份验证和授权，和OpenAPI的安全标准看齐，可以确保Agent之间的交互是可控和安全的。（安全性）

4.有些AI任务，像写代码或者做研究这种，可能要跑好几个小时甚至好几天才能出结果，为了让用户不用傻等，能够随时查看状态，A2A设计了异步机制，通过SSE可以实时反馈进度。（异步性）

5.如果Agent只能发文字，而不能发语音和视频，就显得有些单调了。因此，A2A原生支持音频和视频流传输，为未来的语音助手和视频分析Agent预留了接口。（多模态）

解释一下RAG中的Rerank

Thu, 01 Jan 2026 16:44:33 +0000

Rerank其实一个是对初步检索返回的候选文档列表再次进行排序的过程。

如果把RAG的检索过程类比成公司的招聘过程，则有如下对应关系：

1.初步检索（Retrieval）这一步就类似于HR筛选简历，找工作的人往往很多，HR每天都可能收到上万份甚至几万份简历。

假设有1万份简历，1个HR每天工作8小时，那么1小时之内就得看完1250份，平均到1分钟以内就得看完20多份，这几乎是不可能的。

所以，不可能每份简历HR都会细看。

那她会怎么看呢，主要就是看关键词，比如Java、大模型等等，看到简历上有这些匹配的关键词字眼，就筛选出来。

这样做就会导致看似简历已经匹配上关键词了，但是候选人的能力可能还不太符合要求，只能选出前100个看似还行的候选人。

我们把这个场景对应到RAG的检索过程里面就是，向量检索，它虽然算得快，但是对语义的理解还差点意思。

2.重排序（Rerank）

这个过程就类似于企业招聘过程的业务面试，也就是主管把这100人的简历打印出来仔细阅读，如果觉得候选人的过往经历和工作经验很符合要求，就会约下一步的一对一业务面试。

这个过程花费的时间比较长，消耗的精力也更多，但是筛选出来的候选人也更符合要求。

这也就是RAG检索过程的Rerank，可以精准地判断初步检索返回的文档是不是真正能够回答用户的问题，最后再喂给大模型去生成一个答案。

解释一下RAG

Wed, 31 Dec 2025 15:12:08 +0000

我们可以把大模型想象成一个学霸，这个学霸有两个缺点，一个是他的知识存在滞后性，还有一个就是他不懂一些内部的机密。

RAG（Retrieval Augmented Generation）检索增强生成，其实就是为了解决这两个问题而出现的。

RAG的流程就是检索➡️增强➡️生成：

1.当用户提问时，先不急着去问大模型，而是先去向量数据库中，把和这个问题相关的资料片段全部给找出来；（检索）

2.接下来，把用户提的问题和第1步找到的资料片段缝合在一起，变成一个新的、信息量也更大的提示词；（增强）

3.把第2步生成的提示词喂给大模型，这个时候大模型再根据我们提供的资料，可以生成一个更为准确的答案。（生成）