你好，我是 Hanabi 👋 on Hanabi

大模型AI Agent 入门到实战

Wed, 02 Sep 2026 10:25:59 +0800

系统讲解 AI Agent 的架构与核心模块，结合代码示例介绍工程优化、系统评估，以及意图识别与智能客服的完整实现。

NIO 基础

Mon, 31 Aug 2026 02:40:00 +0800

non-blocking io 非阻塞 IO

1. 三大组件

1.1 Channel & Buffer

channel 有一点类似于 stream，它就是读写数据的双向通道，可以从 channel 将数据读入 buffer，也可以将 buffer 的数据写入 channel，而之前的 stream 要么是输入，要么是输出，channel 比 stream 更为底层


 graph LR
channel --> buffer
buffer --> channel

常见的 Channel 有

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

buffer 则用来缓冲读写数据，常见的 buffer 有

ByteBuffer
- MappedByteBuffer
- DirectByteBuffer
- HeapByteBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer
CharBuffer

1.2 Selector

selector 单从字面意思不好理解，需要结合服务器的设计演化来理解它的用途

多线程版设计


 graph TD
subgraph 多线程版
t1(thread) --> s1(socket1)
t2(thread) --> s2(socket2)
t3(thread) --> s3(socket3)
end

⚠️ 多线程版缺点

内存占用高
线程上下文切换成本高
只适合连接数少的场景

线程池版设计


 graph TD
subgraph 线程池版
t4(thread) --> s4(socket1)
t5(thread) --> s5(socket2)
t4(thread) -.-> s6(socket3)
t5(thread) -.-> s7(socket4)
end

⚠️ 线程池版缺点

阻塞模式下，线程仅能处理一个 socket 连接
仅适合短连接场景

selector 版设计

selector 的作用就是配合一个线程来管理多个 channel，获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，不会让线程吊死在一个 channel 上。适合连接数特别多，但流量低的场景（low traffic）

TypeScript 快速入门

Mon, 31 Aug 2026 02:40:00 +0800

0、TypeScript简介

TypeScript是JavaScript的超集。
它对JS进行了扩展，向JS中引入了类型的概念，并添加了许多新的特性。
TS代码需要通过编译器编译为JS，然后再交由JS解析器执行。
TS完全兼容JS，换言之，任何的JS代码都可以直接当成JS使用。
相较于JS而言，TS拥有了静态类型，更加严格的语法，更强大的功能；TS可以在代码执行前就完成代码的检查，减小了运行时异常的出现的几率；TS代码可以编译为任意版本的JS代码，可有效解决不同JS运行环境的兼容问题；同样的功能，TS的代码量要大于JS，但由于TS的代码结构更加清晰，变量类型更加明确，在后期代码的维护中TS却远远胜于JS。

1、TypeScript 开发环境搭建

下载Node.js
- 64位：https://nodejs.org/dist/v14.15.1/node-v14.15.1-x64.msi
- 32位：https://nodejs.org/dist/v14.15.1/node-v14.15.1-x86.msi
安装Node.js
使用npm全局安装typescript
- 进入命令行
- 输入：npm i -g typescript
创建一个ts文件
使用tsc对ts文件进行编译
- 进入命令行
- 进入ts文件所在目录
- 执行命令：tsc xxx.ts

2、基本类型

类型声明
- 类型声明是TS非常重要的一个特点
- 通过类型声明可以指定TS中变量（参数、形参）的类型
- 指定类型后，当为变量赋值时，TS编译器会自动检查值是否符合类型声明，符合则赋值，否则报错
- 简而言之，类型声明给变量设置了类型，使得变量只能存储某种类型的值
- 语法：
  - let 变量: 类型; let 变量: 类型 = 值; function fn(参数: 类型, 参数: 类型): 类型{ ... }
自动类型判断
- TS拥有自动的类型判断机制
- 当对变量的声明和赋值是同时进行的，TS编译器会自动判断变量的类型
- 所以如果你的变量的声明和赋值时同时进行的，可以省略掉类型声明

类型：

类型	例子	描述
number	1, -33, 2.5	任意数字
string	‘hi’, “hi”, `hi`	任意字符串
boolean	true、false	布尔值true或false
字面量	其本身	限制变量的值就是该字面量的值
any	*	任意类型
unknown	*	类型安全的any
void	空值（undefined）	没有值（或undefined）
never	没有值	不能是任何值
object	{name:‘孙悟空’}	任意的JS对象
array	[1,2,3]	任意JS数组
tuple	[4,5]	元素，TS新增类型，固定长度数组
enum	enum{A, B}	枚举，TS中新增类型

number

从零实现 Coze Studio：项目分析与阶段拆解

Sun, 30 Aug 2026 20:00:00 +0800

最近在做一个「从零实现 Coze Studio」的项目。不是抄代码，而是把它的领域模型、表结构和模块边界吃透之后，自己再实现一遍——这是吃透一个优秀开源项目最扎实的路径。

这篇文章是这个系列的总纲：先把原项目分析清楚（架构、技术栈、55 张表），再把整个实现拆成准备阶段 + 11 个实施阶段。每个阶段开始前，都先用 Mermaid 把该阶段涉及的表结构和依赖关系画出来，先分析、再动手。

2026-09-10 更新：本文按 minicoze 当前的实际技术方案梳理了阶段 0～2，保留对原版的完整分析作为对照。与原版的差异——PostgreSQL 单库替代 MySQL+Milvus+ES、provider-first 模型接入、模型域两层表结构、软删实现等——均在文中逐条标注。

路径约定：下文所有路径均相对于仓库根目录，分析基于当前开源版本，表结构以 docker/volumes/mysql/schema.sql 为准（共 55 张表）。

第 0 阶段（准备）：项目全景与开发环境

动手写第一行代码之前，先把地图看全。这个阶段不产出功能，产出的是对全局的判断。

0.1 仓库全景

Coze Studio 是字节开源的一站式 AI Agent 开发平台（可视化编排智能体 / 应用 / 工作流）。仓库顶层结构：

coze-studio/
├── backend/ # Go 后端（主体）
│ ├── api/ # HTTP 层：handler / router / middleware / model
│ ├── application/ # 应用服务层（按模块编排领域对象）
│ ├── domain/ # 领域层：17 个领域模块（核心）
│ ├── crossdomain/ # 跨领域依赖的接口定义（16 个）
│ ├── infra/ # 基础设施：orm、rdb、cache、storage、embedding、es、eventbus...
│ ├── conf/ # 配置：模型元数据、提示词模板、插件产物...
│ └── types/ pkg/ # 公共类型与工具
├── frontend/ # React + TypeScript 前端（monorepo）
├── idl/ # Thrift IDL：API 契约的「唯一事实来源」
├── docker/ # 部署：docker-compose + atlas 数据库迁移 + 卷挂载
└── helm/ # K8s 部署

后端是标准的 DDD 分层，以 domain/user 为例，每个领域都是同一套骨架：

Netty 入门

Mon, 31 Aug 2026 02:40:00 +0800

1. 概述

1.1 Netty 是什么？

Netty is an asynchronous event-driven network application framework
for rapid development of maintainable high performance protocol servers & clients.

Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端

1.2 Netty 的作者

他还是另一个著名网络应用框架 Mina 的重要贡献者

1.3 Netty 的地位

Netty 在 Java 网络应用框架中的地位就好比：Spring 框架在 JavaEE 开发中的地位

以下的框架都使用了 Netty，因为它们有网络通信需求！

Cassandra - nosql 数据库
Spark - 大数据分布式计算框架
Hadoop - 大数据分布式存储框架
RocketMQ - ali 开源的消息队列
ElasticSearch - 搜索引擎
gRPC - rpc 框架
Dubbo - rpc 框架
Spring 5.x - flux api 完全抛弃了 tomcat ，使用 netty 作为服务器端
Zookeeper - 分布式协调框架

1.4 Netty 的优势

Netty vs NIO，工作量大，bug 多
- 需要自己构建协议
- 解决 TCP 传输问题，如粘包、半包
- epoll 空轮询导致 CPU 100%
- 对 API 进行增强，使之更易用，如 FastThreadLocal => ThreadLocal，ByteBuf => ByteBuffer
Netty vs 其它网络应用框架
- Mina 由 apache 维护，将来 3.x 版本可能会有较大重构，破坏 API 向下兼容性，Netty 的开发迭代更迅速，API 更简洁、文档更优秀
- 久经考验，16年，Netty 版本
  - 2.x 2004
  - 3.x 2008
  - 4.x 2013
  - 5.x 已废弃（没有明显的性能提升，维护成本高）

2. Hello World

2.1 目标

开发一个简单的服务器端和客户端

Promise

Mon, 31 Aug 2026 02:40:00 +0800

一、前言：为什么会出现Promise?

Promise的重要性我认为没有必要多讲，概括起来说就是五个字：必！须！得！掌！握！。

而且还要掌握透彻，在实际的使用中，有非常多的应用场景我们不能立即知道应该如何继续往下执行。

最常见的一个场景就是ajax请求，通俗来说，由于网速的不同，可能你得到返回值的时间也是不同的，

这个时候我们就需要等待，结果出来了之后才知道怎么样继续下去。

let xhr = new XMLHttpRequest();
xhr.open('get', 'https://v0.yiketianqi.com/api?unescape=1&version=v61&appid=82294778&appsecret=4PKVFula&city=%E5%8C%97%E4%BA%AC');
xhr.send();
xhr.onreadystatechange = function () {
 if (xhr.readyState === 4) {
 if (xhr.status >= 200 && xhr.status < 300) {
 console.log(xhr.responseText)
 }
 }
}

在ajax的原生实现中，利用了onreadystatechange事件，当该事件触发并且符合一定条件时，才能拿到想要的数据，之后才能开始处理数据，这样做看上去并没有什么麻烦，但如果这个时候，我们还需要另外一个ajax请求，这个新ajax请求的其中一个参数，得从上一个ajax请求中获取，这个时候我们就不得不等待上一个接口请求完成之后，再请求后一个接口。

let xhr = new XMLHttpRequest();
xhr.open('get', 'https://v0.yiketianqi.com/api?unescape=1&version=v61&appid=82294778&appsecret=4PKVFula&city=%E5%8C%97%E4%BA%AC');
xhr.send();
xhr.onreadystatechange = function () {
 if (xhr.readyState === 4) {
 if (xhr.status >= 200 && xhr.status < 300) {
 console.log(xhr.responseText)
 
 //伪代码....
 let xhr = new XMLHttpRequest();
 xhr.open('get','http://www.xx.com?a'+xhr.responseText);
 xhr.send();
 xhr.onreadystatechange = function(){
 if(xhr.readyState === 4){
 if(xhr.status>=200 && xhr.status<300){
 console.log(xhr.responseText)
 
 }
 }
 }
 }
 }
}

当出现第三个ajax(甚至更多)仍然依赖上一个请求时，我们的代码就变成了一场灾难。

这场灾难，往往也被称为回调地狱。

因此我们需要一个叫做Promise的东西，来解决这个问题，当然，除了回调地狱之外，还有个非常重要的需求就是

为了代码更加具有可读性和可维护性，我们需要将数据请求与数据处理明确的区分开来。

上面的写法，是完全没有区分开，当数据变得复杂时，也许我们自己都无法轻松维护自己的代码了。

这也是模块化过程中，必须要掌握的一个重要技能，请一定重视。

二、Promise是什么?

Promise是异步编程的一种解决方案，比传统的解决方案回调函数更合理、更强大。

ES6将其写进了语言标准，统一了用法，原生提供了Promise对象。

指定回调函数的方式也变得更加灵活易懂，也解决了异步回调地狱的问题

旧方案是单纯使用回调函数，常见的异步操作有：定时器、fs模块、ajax、数据库操作

从语法上说，Promise是一个构造函数；

从功能上说，Promise对象用来封装一个异步操作并可以获取其成功/失败的结果值。

2.1 Promise的初体验

创建promise对象（pending状态）

const p = new Promise(executor);

其中：

executor函数: 执行器 (resolve, reject) => {}

resolve函数: 内部定义成功时我们调用的函数 value => {}

TypeScript 面向对象

Mon, 31 Aug 2026 02:40:00 +0800

面向对象是程序中一个非常重要的思想，它被很多同学理解成了一个比较难，比较深奥的问题，其实不然。面向对象很简单，简而言之就是程序之中所有的操作都需要通过对象来完成。

举例来说：
- 操作浏览器要使用window对象
- 操作网页要使用document对象
- 操作控制台要使用console对象

一切操作都要通过对象，也就是所谓的面向对象，那么对象到底是什么呢？这就要先说到程序是什么，计算机程序的本质就是对现实事物的抽象，抽象的反义词是具体，比如：照片是对一个具体的人的抽象，汽车模型是对具体汽车的抽象等等。程序也是对事物的抽象，在程序中我们可以表示一个人、一条狗、一把枪、一颗子弹等等所有的事物。一个事物到了程序中就变成了一个对象。

在程序中所有的对象都被分成了两个部分数据和功能，以人为例，人的姓名、性别、年龄、身高、体重等属于数据，人可以说话、走路、吃饭、睡觉这些属于人的功能。数据在对象中被成为属性，而功能就被称为方法。所以简而言之，在程序中一切皆是对象。

1、类（class）

要想面向对象，操作对象，首先便要拥有对象，那么下一个问题就是如何创建对象。要创建对象，必须要先定义类，所谓的类可以理解为对象的模型，程序中可以根据类创建指定类型的对象，举例来说：可以通过Person类来创建人的对象，通过Dog类创建狗的对象，通过Car类来创建汽车的对象，不同的类可以用来创建不同的对象。

定义类：

class 类名 {
	属性名: 类型;

	constructor(参数: 类型){
		this.属性名 = 参数;
	}

	方法名(){
		....
	}

}

示例：

class Person{
 name: string;
 age: number;

 constructor(name: string, age: number){
 this.name = name;
 this.age = age;
 }

 sayHello(){
 console.log(`大家好，我是${this.name}`);
 }
}

使用类：

const p = new Person('孙悟空', 18);
p.sayHello();

2、面向对象的特点

封装
- 对象实质上就是属性和方法的容器，它的主要作用就是存储属性和方法，这就是所谓的封装
- 默认情况下，对象的属性是可以任意的修改的，为了确保数据的安全性，在TS中可以对属性的权限进行设置
- 只读属性（readonly）：
  - 如果在声明属性时添加一个readonly，则属性便成了只读属性无法修改
- TS中属性具有三种修饰符：
  - public（默认值），可以在类、子类和对象中修改
  - protected ，可以在类、子类中修改
  - private ，可以在类中修改
- 示例：
  - public
    - class Person{ public name: string; // 写或什么都不写都是public public age: number; constructor(name: string, age: number){ this.name = name; // 可以在类中修改 this.age = age; } sayHello(){ console.log(`大家好，我是${this.name}`); } } class Employee extends Person{ constructor(name: string, age: number){ super(name, age); this.name = name; //子类中可以修改 } } const p = new Person('孙悟空', 18); p.name = '猪八戒';// 可以通过对象修改
  - protected

Netty 进阶

Mon, 31 Aug 2026 02:40:00 +0800

1. 粘包与半包

1.1 粘包现象

服务端代码

public class HelloWorldServer {
 static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class);
 void start() {
 NioEventLoopGroup boss = new NioEventLoopGroup(1);
 NioEventLoopGroup worker = new NioEventLoopGroup();
 try {
 ServerBootstrap serverBootstrap = new ServerBootstrap();
 serverBootstrap.channel(NioServerSocketChannel.class);
 serverBootstrap.group(boss, worker);
 serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
 @Override
 protected void initChannel(SocketChannel ch) throws Exception {
 ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
 ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
 @Override
 public void channelActive(ChannelHandlerContext ctx) throws Exception {
 log.debug("connected {}", ctx.channel());
 super.channelActive(ctx);
 }

 @Override
 public void channelInactive(ChannelHandlerContext ctx) throws Exception {
 log.debug("disconnect {}", ctx.channel());
 super.channelInactive(ctx);
 }
 });
 }
 });
 ChannelFuture channelFuture = serverBootstrap.bind(8080);
 log.debug("{} binding...", channelFuture.channel());
 channelFuture.sync();
 log.debug("{} bound...", channelFuture.channel());
 channelFuture.channel().closeFuture().sync();
 } catch (InterruptedException e) {
 log.error("server error", e);
 } finally {
 boss.shutdownGracefully();
 worker.shutdownGracefully();
 log.debug("stoped");
 }
 }

 public static void main(String[] args) {
 new HelloWorldServer().start();
 }
}

客户端代码希望发送 10 个消息，每个消息是 16 字节

高频面试题

Mon, 31 Aug 2026 02:40:00 +0800

SpringCloud常用组件有哪些？

最常用的5个组件是Nacos、Gateway网关、Feign远程调用、Sentinel熔断降级和Ribbon负载均衡

其中Nacos是eureka的升级版，是阿里巴巴开发的，不仅仅可以作为注册中心，还可以作为配置中心

注册中心

服务提供者在启动时，会将自己的元数据信息注册到Nacos服务器中，同时Nacos也会对注册的服务进行心跳检测，以确保服务的可用性，服务消费者在需要调用服务时，可以通过Nacos的服务发现功能获取服务提供者的地址列表，从而实现负载均衡和服务调用

配置中心

配置中心则是负责管理应用程序的配置信息，nacos提供了一个可视化的配置管理界面，支持多种格式的配置文件，支持动态配置管理，当配置信息发生变化时，Nacos会自动推送最新的配置信息给应用程序，从而实现配置的实时更新

网关Gateway

用于实现服务的路由、负载均衡、过滤和熔断等功能。采用了异步非阻塞的模型，采用Netty作为底层的HTTP库，提高了网关的吞吐量和性能。

网关中的过滤器：

默认过滤器(只能使用SpringCloudGateway自带的过滤器)
路由过滤器(只能使用SpringCloudGateway自带的过滤器)
全局过滤器(创建一个类实现GlobalFilter接口,重写filter方法.可用于鉴权)
三种过滤器默认执行顺序(默认 -> 路由 -> 全局)全局过滤器实现Ordered接口,重写

getOrder方法,返回-1即可实现在其他两个过滤器前执行(默认和路由过滤器的Order默认是1开始的)

Feign远程调用

定义接口：在Feign客户端的接口中定义需要调用的远程服务的方法，使用注解指定服务名称、请求方式、请求路径、请求参数，响应结果等信息。
解析接口：在应用启动时，Feign会扫描所有带有@FeignClient注解的接口，并将其解析成可执行的HTTP请求，生成动态代理对象并保存在Spring的容器中。
发起请求：当应用调用Feign客户端的接口方法时，Feign中依赖的ribbon组件会去获取@FeignClient注解中name属性的值，即服务名，通过这个服务名去找注册中心拉取服务提供者列表，缓存到本地。基于负载均衡的方式选择一个服务提供者，根据接口声明的方法上的请求路径，请求参数，请求方法，发送http请求
响应结果：远程服务接收到请求后，会根据请求路径和请求参数执行相应的逻辑，并将结果封装成HTTP响应返回。Feign客户端接收到响应后，根据响应结果类型进行反序列化，并返回给应用程序。以接口和注解的方式，实现对HTTP请求的映射和调用

底层原理：

Feign的底层实现基于动态代理和HTTP客户端，它将接口与HTTP请求/响应绑定在一起，通过注解配置的方式简化了服务调用的过程，提高了代码的可读性和可维护性。

Sentinel熔断降级

Sentinel是一款开源的服务治理组件，主要提供流量控制、熔断降级和系统负载保护等功能。熔断降级是指在分布式系统中，即当系统出现异常或不可用时，通过断路器的方式将请求快速失败，避免请求不断堆积，引起系统的崩溃（雪崩）。Sentinel在防止微服雪崩上有以下4种方案:

超时处理：设定超时时间，请求超过一定时间没有响应就返回错误信息，不会无休止等待
舱壁模式：限定每个业务能使用的线程数，避免耗尽整个tomcat的资源，因此也叫线程隔离
熔断降级：由断路器统计业务执行的异常比例，如果超出阈值则会熔断该业务，拦截访问该业务的一切请求
流量控制：限制业务访问的QPS，避免服务因流量的突增而故障

Ribbon负载均衡

主要作用是在服务消费者与服务提供者之间进行负载均衡，将请求分发到不同的服务实例上，从而提高系统的可用性和性能。Ribbon通过向注册中心获取服务实例信息，并通过算法选择合适的实例进行请求转发，从而实现负载均衡。可以通过配置不同的负载均衡策略，实现不同的负载均衡方式，如轮询、随机、加权随机、最少活跃数

Spring Bean的生命周期

bean的生命周期是指：Spring 容器在管理 Bean 时，会根据特定的顺序进行初始化、依赖注入、执行业务逻辑等一系列操作，最终销毁 Bean；

实例化：Spring容器通过反射或工厂方法创建bean的实例。
属性注入：Spring容器将bean的属性值和依赖项注入到实例中。
初始化：如果bean实现了InitializingBean接口，Spring容器将调用afterPropertiesSet()方法；如果在bean配置中声明了init-method属性，则Spring容器将调用指定的方法。（此时就可以使用bean了）
销毁：如果bean实现了DisposableBean接口，Spring容器将在关闭应用程序上下文时调用destroy()方法；如果在bean配置中声明了destroy-method属性，则Spring容器将调用指定的方法。

【注意】：

单例bean，只有一个实例会在应用程序上下文中存在，并且在容器关闭时销毁；

对于原型bean，每次调用getBean()方法时都会创建一个新实例，因此不会进行销毁。

SpringMVC 执行流程

SpringBoot==> web起步依赖(SpringMVC) SpringMVC Spring MyBatis/MyBatisPlus

SpringMVC请求原理很简单：说白了就是用一个DispatcherServlet 封装了一个Servlet(web组件)的调度中心，由调度中心帮我们调用我们的处理方法：在这个过程中调度中心委托给各个组件执行具体工作，比如帮我们映射方法请求、帮我解析参数、调用处理方法、响应数据和页面等。

localhost:8092/coupons/1/issue

/coupons/1/issue==处理器映射器==>找到对应的Handler(还不是直接的Controller)==适配器==>转换成了Haddler(我们写的Controller)

mvc的执行流程大致分为11步：

用户发送出请求到前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping（处理器映射器）。
HandlerMapping找到具体的处理器(可查找xml配置或注解配置)，生成处理器对象及处理器拦截器(如果有)，再一起返回给DispatcherServlet。
DispatcherServlet调用HandlerAdapter（处理器适配器）。
HandlerAdapter经过适配调用具体的处理器（Handler/Controller）。
Controller执行完成返回ModelAndView对象。
HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet。
DispatcherServlet将ModelAndView传给ViewReslover（视图解析器）。
ViewReslover解析后返回具体View（视图）。
DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
DispatcherServlet响应用户。

Netty 优化与源码

Mon, 31 Aug 2026 02:40:00 +0800

1. 优化

1.1 扩展序列化算法

序列化，反序列化主要用在消息正文的转换上

序列化时，需要将 Java 对象变为要传输的数据（可以是 byte[]，或 json 等，最终都需要变成 byte[]）
反序列化时，需要将传入的正文数据还原成 Java 对象，便于处理

目前的代码仅支持 Java 自带的序列化，反序列化机制，核心代码如下

// 反序列化
byte[] body = new byte[bodyLength];
byteByf.readBytes(body);
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(body));
Message message = (Message) in.readObject();
message.setSequenceId(sequenceId);

// 序列化
ByteArrayOutputStream out = new ByteArrayOutputStream();
new ObjectOutputStream(out).writeObject(message);
byte[] bytes = out.toByteArray();

为了支持更多序列化算法，抽象一个 Serializer 接口

public interface Serializer {

 // 反序列化方法
 <T> T deserialize(Class<T> clazz, byte[] bytes);

 // 序列化方法
 <T> byte[] serialize(T object);

}

提供两个实现，我这里直接将实现加入了枚举类 Serializer.Algorithm 中