# 完整数据流程设计 ## 用户需求 1. **自动解析**：服务端在给定协议下自动解析数据到header和struct，Handler中直接使用 2. **自动编码**：服务端写数据时自动编码 ## 完整数据流程 ### 读数据流程（自动解析） ``` 1. 数据到达 Connection.Read() → []byte (原始字节) ↓ 2. 识别协议 根据配置或数据特征识别协议 → Protocol ↓ 3. 协议解码 Protocol.Decode(rawData) → FrameHeader + []byte (帧头 + 数据部分) ↓ 4. 识别编解码器 根据配置或路由配置识别编解码器 → Codec ↓ 5. 获取请求类型 从路由配置获取请求类型 → RequestType (reflect.Type) ↓ 6. 数据解码 Codec.Decode(bodyBytes, requestType) → Go Struct ↓ 7. 创建Request对象 Request.SetHeader(header) Request.SetData(struct) // 已解析的结构体 ↓ 8. 创建Context Context包含Request和Response ↓ 9. Handler执行 req.Data().(*MyStruct) // 直接使用解析后的结构体 ``` ### 写数据流程（自动编码） ``` 1. Handler调用 resp.Write(struct) // Go对象 ↓ 2. 编解码器编码 Codec.Encode(struct) → []byte (序列化后的数据) ↓ 3. 协议编码 Protocol.Encode(bodyBytes, header) → []byte (添加帧头) ↓ 4. 写入连接 Connection.Write(frameData) → 发送到客户端 ``` ## 关键实现点 ### 1. 服务器自动解析 在服务器接收到数据后，立即进行解析： ```go func (h *eventHandler) OnTraffic(c gnet.Conn) { // 1. 读取原始数据 rawData, _ := c.Peek(-1) // 2. 识别协议 protocol := h.identifyProtocol(rawData) // 3. 创建Request对象（初始状态） req := request.New(rawData, protocol) // 4. 创建Response对象 resp := response.New(connAdapter, protocol, h.codecRegistry, h.defaultCodec) // 5. 创建Context ctx := context.New(parentCtx, conn, req, resp) // 6. 路由匹配（会返回路由配置） route, handler := h.router.Match(rawData, ctx) if route == nil { return } // 7. 自动解析请求数据 if route.RequestType() != nil { h.parseRequest(req, rawData, route, protocol, h.codecRegistry) } // 8. 执行Handler（Handler中可以直接使用解析后的数据） handler(ctx) } ``` ### 2. 自动解析逻辑 ```go func (h *eventHandler) parseRequest(req request.Request, rawData []byte, route Route, protocol Protocol, codecRegistry CodecRegistry) { // 1. 协议解码（提取帧头和数据） header, bodyBytes, err := protocol.Decode(rawData) if err != nil { // 处理错误 return } req.SetHeader(header) req.SetDataBytes(bodyBytes) // 2. 数据解码（将字节解码为结构体） requestType := route.RequestType() if requestType != nil { // 创建结构体实例 body := reflect.New(requestType.Elem()).Interface() // 获取编解码器 codec := codecRegistry.Get(route.Codec()) // 或使用默认编解码器 if codec == nil { codec = codecRegistry.Default() } // 解码数据 if err := codec.Decode(bodyBytes, body); err != nil { // 处理错误 return } // 设置到Request req.SetData(body) } } ``` ### 3. 自动编码逻辑 ```go func (resp *responseImpl) Write(data interface{}) error { // 1. 获取编解码器 codec := resp.codecRegistry.Default() // 或从路由获取 // 2. 编解码器编码（Go对象 → 字节） bodyBytes, err := codec.Encode(data) if err != nil { return err } // 3. 协议编码（添加帧头） header := resp.Header() frameData, err := resp.protocol.Encode(bodyBytes, header) if err != nil { return err } // 4. 写入连接 return resp.conn.Write(frameData) } ``` ## Handler使用示例 ### 有帧头协议 ```go type LoginRequest struct { Username string `json:"username"` Password string `json:"password"` } type LoginResponse struct { Code int `json:"code"` Token string `json:"token"` } // 注册路由 router.RegisterString( "login", loginHandler, router.WithRequestType(&LoginRequest{}), ) // Handler实现 func loginHandler(ctx context.Context) error { req := ctx.Request() resp := ctx.Response() // 直接使用解析后的数据（无需手动解码） loginReq := req.Data().(*LoginRequest) username := loginReq.Username password := loginReq.Password // 读取协议帧头（如果有） header := req.Header() if header != nil { messageType := header.Get("message_type") sequence := header.Get("sequence") // 使用帧头信息 } // 处理业务逻辑 token := authenticate(username, password) // 设置响应帧头（如果有） respHeader := resp.Header() if respHeader != nil { respHeader.Set("message_type", 0x02) respHeader.Set("sequence", sequence) respHeader.Set("status", 0) } // 写入响应（自动编码） return resp.Write(LoginResponse{ Code: 200, Token: token, }) } ``` ### 无帧头协议 ```go type EchoRequest struct { Message string `json:"message"` } type EchoResponse struct { Message string `json:"message"` } // 注册路由 router.RegisterString( "echo", echoHandler, router.WithRequestType(&EchoRequest{}), ) // Handler实现 func echoHandler(ctx context.Context) error { req := ctx.Request() resp := ctx.Response() // 直接使用解析后的数据（无帧头协议，header为nil） echoReq := req.Data().(*EchoRequest) // 写入响应（自动编码，协议会自动添加\n等分隔符） return resp.Write(EchoResponse{ Message: echoReq.Message, }) } ``` ## 协议帧头处理 ### 有帧头协议（如nnet） ```go // nnet协议格式 [Magic(4 bytes)][Version(1 byte)][Length(4 bytes)][Data(N bytes)][Checksum(2 bytes)] // 协议解码 func (p *NNetProtocol) Decode(data []byte) (FrameHeader, []byte, error) { // 提取帧头 header := &NNetFrameHeader{ Magic: data[0:4], Version: data[4], Length: binary.BigEndian.Uint32(data[5:9]), Checksum: binary.BigEndian.Uint16(data[9+length:11+length]), } // 提取数据部分 bodyBytes := data[9:9+length] return header, bodyBytes, nil } // 协议编码 func (p *NNetProtocol) Encode(data []byte, header FrameHeader) ([]byte, error) { // 构建完整的协议帧 frame := make([]byte, 0, 11+len(data)) frame = append(frame, header.Magic...) frame = append(frame, header.Version) // ... 其他帧头字段 frame = append(frame, data...) frame = append(frame, header.Checksum...) return frame, nil } ``` ### 无帧头协议（如\n分割） ```go // 无帧头协议 func (p *NoHeaderProtocol) HasHeader() bool { return false } // 协议解码 func (p *NoHeaderProtocol) Decode(data []byte) (FrameHeader, []byte, error) { // 无帧头，直接返回数据（去除分隔符） data = bytes.TrimSuffix(data, []byte{'\n'}) return nil, data, nil // 返回nil header } // 协议编码 func (p *NoHeaderProtocol) Encode(data []byte, header FrameHeader) ([]byte, error) { // 无帧头，直接返回数据（添加分隔符） return append(data, '\n'), nil } ``` ## 路由配置 ### 支持指定请求类型 ```go // RouteOption 路由选项 type RouteOption func(*routeConfig) // WithRequestType 指定请求类型 func WithRequestType(typ interface{}) RouteOption { return func(cfg *routeConfig) { cfg.requestType = reflect.TypeOf(typ) } } // WithCodec 指定编解码器 func WithCodec(codecName string) RouteOption { return func(cfg *routeConfig) { cfg.codecName = codecName } } // 使用示例 router.RegisterString( "login", loginHandler, router.WithRequestType(&LoginRequest{}), router.WithCodec("json"), ) ``` ## 总结 ### ✅ 已实现 1. **Context职责分离**：Context只负责状态管理 2. **Request和Response对象**：负责数据读写 3. **自动编码**：Response.Write()自动编码 4. **接口定义**：Request、Response、Protocol接口已定义 ### 🚧 待实现 1. **自动解析**：服务器自动解析数据 2. **路由配置**：支持指定请求类型 3. **协议实现更新**：更新现有协议实现 4. **服务器代码更新**：更新服务器以使用新架构 ## 下一步 1. 实现自动解析逻辑 2. 更新路由接口，支持指定请求类型 3. 更新协议实现 4. 更新服务器代码 5. 编写测试用例