|
|
# 架构重新设计 - 问题解答
|
|
|
|
|
|
## 问题1：Context不应该包含数据写入读取功能
|
|
|
|
|
|
**您的思考：** ✅ **完全正确**
|
|
|
|
|
|
Context应该专注于状态管理和流程控制，数据读写应该交给Request、Response或Connection完成。
|
|
|
|
|
|
**新的设计：**
|
|
|
|
|
|
```go
|
|
|
// Context只负责状态管理
|
|
|
type Context interface {
|
|
|
context.Context
|
|
|
Request() Request // 获取Request对象
|
|
|
Response() Response // 获取Response对象
|
|
|
Connection() Connection // 获取Connection对象
|
|
|
Set(key string, value interface{})
|
|
|
Get(key string) interface{}
|
|
|
}
|
|
|
|
|
|
// Request负责数据读取
|
|
|
type Request interface {
|
|
|
Raw() []byte // 原始数据
|
|
|
Data() []byte // 协议解码后的数据
|
|
|
Decode(v interface{}) error // 解码为Go对象
|
|
|
Header() FrameHeader // 协议帧头
|
|
|
}
|
|
|
|
|
|
// Response负责数据写入
|
|
|
type Response interface {
|
|
|
Write(data interface{}) error // 写入数据（自动编码）
|
|
|
WriteBytes(data []byte) error // 写入原始字节
|
|
|
SetHeader(header FrameHeader) // 设置协议帧头
|
|
|
Send() error // 发送响应
|
|
|
}
|
|
|
```
|
|
|
|
|
|
## 问题2：协议帧 = 帧头（协议处理）+ 帧数据（Codec处理）
|
|
|
|
|
|
**您的理解：** ✅ **完全正确**
|
|
|
|
|
|
协议帧的结构：
|
|
|
```
|
|
|
[帧头] + [数据]
|
|
|
↓ ↓
|
|
|
Protocol Codec
|
|
|
```
|
|
|
|
|
|
**设计实现：**
|
|
|
|
|
|
```go
|
|
|
// Protocol处理帧头
|
|
|
type Protocol interface {
|
|
|
HasHeader() bool // 是否有帧头
|
|
|
Encode(data []byte, header FrameHeader) ([]byte, error) // 添加帧头
|
|
|
Decode(data []byte) (FrameHeader, []byte, error) // 提取帧头和数据
|
|
|
}
|
|
|
|
|
|
// Codec处理数据序列化
|
|
|
type Codec interface {
|
|
|
Encode(v interface{}) ([]byte, error) // 序列化
|
|
|
Decode(data []byte, v interface{}) error // 反序列化
|
|
|
}
|
|
|
```
|
|
|
|
|
|
**数据流程：**
|
|
|
|
|
|
读数据：
|
|
|
```
|
|
|
原始字节 → Protocol.Decode() → 帧头 + 数据 → Codec.Decode() → Go对象
|
|
|
```
|
|
|
|
|
|
写数据：
|
|
|
```
|
|
|
Go对象 → Codec.Encode() → 数据 → Protocol.Encode() → 帧头 + 数据 → 原始字节
|
|
|
```
|
|
|
|
|
|
## 问题3：写数据时希望可以连同帧头一起写入
|
|
|
|
|
|
**您的需求：** ✅ **已支持**
|
|
|
|
|
|
**实现方式：**
|
|
|
|
|
|
### 方式1：自动处理（推荐）
|
|
|
|
|
|
```go
|
|
|
func handler(ctx context.Context) error {
|
|
|
resp := ctx.Response()
|
|
|
|
|
|
// 设置协议帧头
|
|
|
header := resp.Header()
|
|
|
if header != nil {
|
|
|
header.Set("message_type", 0x01)
|
|
|
header.Set("sequence", 123)
|
|
|
}
|
|
|
|
|
|
// 写入数据（自动添加帧头）
|
|
|
return resp.Write(MyResponse{Code: 200})
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 方式2：手动构建
|
|
|
|
|
|
```go
|
|
|
func handler(ctx context.Context) error {
|
|
|
resp := ctx.Response()
|
|
|
|
|
|
// 手动构建帧头
|
|
|
header := NewFrameHeader()
|
|
|
header.Set("message_type", 0x01)
|
|
|
resp.SetHeader(header)
|
|
|
|
|
|
// 写入数据
|
|
|
return resp.Write(MyResponse{Code: 200})
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 方式3：直接写入原始字节
|
|
|
|
|
|
```go
|
|
|
func handler(ctx context.Context) error {
|
|
|
resp := ctx.Response()
|
|
|
|
|
|
// 手动构建完整的协议帧
|
|
|
frameHeader := []byte{0x01, 0x02, 0x03} // 自定义帧头
|
|
|
data := []byte("your data")
|
|
|
frame := append(frameHeader, data...)
|
|
|
|
|
|
// 直接写入（绕过自动编码）
|
|
|
return resp.WriteBytes(frame)
|
|
|
}
|
|
|
```
|
|
|
|
|
|
## 问题4：无帧头协议支持（如\n分割）
|
|
|
|
|
|
**您的需求：** ✅ **已支持**
|
|
|
|
|
|
**实现方式：**
|
|
|
|
|
|
### 无帧头协议实现
|
|
|
|
|
|
```go
|
|
|
type NoHeaderProtocol struct{}
|
|
|
|
|
|
func (p *NoHeaderProtocol) HasHeader() bool {
|
|
|
return false // 无帧头
|
|
|
}
|
|
|
|
|
|
func (p *NoHeaderProtocol) Encode(data []byte, header FrameHeader) ([]byte, error) {
|
|
|
// 无帧头协议，直接返回数据，添加分隔符
|
|
|
return append(data, '\n'), nil
|
|
|
}
|
|
|
|
|
|
func (p *NoHeaderProtocol) Decode(data []byte) (FrameHeader, []byte, error) {
|
|
|
// 无帧头协议，直接返回数据（去除分隔符）
|
|
|
data = bytes.TrimSuffix(data, []byte{'\n'})
|
|
|
return nil, data, nil // 返回nil header
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 使用示例
|
|
|
|
|
|
```go
|
|
|
func handler(ctx context.Context) error {
|
|
|
req := ctx.Request()
|
|
|
resp := ctx.Response()
|
|
|
|
|
|
// 无帧头协议，直接读取数据
|
|
|
rawData := req.Data() // 已经是去除分隔符的数据
|
|
|
|
|
|
// 处理数据
|
|
|
result := processData(rawData)
|
|
|
|
|
|
// 写入响应（协议会自动添加\n）
|
|
|
return resp.WriteString(result)
|
|
|
}
|
|
|
```
|
|
|
|
|
|
## 问题5：综合考虑路由、协议选择、协议版本等功能
|
|
|
|
|
|
**您的需求：** ✅ **已考虑**
|
|
|
|
|
|
### 路由集成
|
|
|
|
|
|
路由可以在不同层次进行匹配：
|
|
|
|
|
|
1. **协议层匹配**：根据协议帧头匹配
|
|
|
```go
|
|
|
// 根据帧头的message_type字段匹配
|
|
|
router.RegisterFrameHeader("message_type", "==", 0x01, handler)
|
|
|
```
|
|
|
|
|
|
2. **数据层匹配**：根据解码后的数据匹配
|
|
|
```go
|
|
|
// 根据JSON数据的path字段匹配
|
|
|
router.RegisterFrameData("path", "==", "/api/user", handler)
|
|
|
```
|
|
|
|
|
|
3. **原始数据匹配**：根据原始字节匹配（无帧头协议）
|
|
|
```go
|
|
|
// 根据原始字符串匹配
|
|
|
router.RegisterString("get_user\n", handler)
|
|
|
```
|
|
|
|
|
|
### 协议选择
|
|
|
|
|
|
```go
|
|
|
// 配置协议
|
|
|
cfg := &Config{
|
|
|
Protocol: ProtocolConfig{
|
|
|
Name: "nnet", // 协议名称
|
|
|
Version: "1.0", // 协议版本
|
|
|
HasHeader: true, // 是否有帧头
|
|
|
},
|
|
|
}
|
|
|
|
|
|
// 服务器自动选择协议
|
|
|
server := NewServer(cfg)
|
|
|
```
|
|
|
|
|
|
### 协议版本管理
|
|
|
|
|
|
```go
|
|
|
// 协议管理器支持多版本
|
|
|
protocolManager.Register(nnetProtocolV1) // 版本1.0
|
|
|
protocolManager.Register(nnetProtocolV2) // 版本2.0
|
|
|
|
|
|
// 根据数据自动识别版本
|
|
|
protocol, version := protocolManager.Identify(data)
|
|
|
```
|
|
|
|
|
|
## 问题6：API设计要精简、现代化
|
|
|
|
|
|
**您的需求：** ✅ **已实现**
|
|
|
|
|
|
### API特点
|
|
|
|
|
|
1. **简洁直观**
|
|
|
```go
|
|
|
// 读取数据
|
|
|
req.Decode(&data)
|
|
|
|
|
|
// 写入数据
|
|
|
resp.Write(data)
|
|
|
```
|
|
|
|
|
|
2. **类型安全**
|
|
|
```go
|
|
|
// 使用接口和泛型保证类型安全
|
|
|
req.Decode(&MyRequest{})
|
|
|
resp.Write(MyResponse{})
|
|
|
```
|
|
|
|
|
|
3. **链式调用**
|
|
|
```go
|
|
|
// 支持流畅的API
|
|
|
resp.Header().Set("type", 0x01).Write(data)
|
|
|
```
|
|
|
|
|
|
4. **自动处理**
|
|
|
```go
|
|
|
// 自动编码/解码
|
|
|
req.Decode(&data) // 自动进行protocol decode + codec decode
|
|
|
resp.Write(data) // 自动进行codec encode + protocol encode
|
|
|
```
|
|
|
|
|
|
## 完整的数据流程
|
|
|
|
|
|
### 读数据流程
|
|
|
|
|
|
```
|
|
|
1. Connection.Read() → []byte (原始字节)
|
|
|
↓
|
|
|
2. Protocol.Decode() → FrameHeader + []byte (帧头 + 数据)
|
|
|
↓
|
|
|
3. Request.Data() → []byte (数据部分)
|
|
|
↓
|
|
|
4. Request.Decode() → interface{} (Go对象，经过codec decode)
|
|
|
↓
|
|
|
5. 路由匹配（可以根据帧头或数据匹配）
|
|
|
↓
|
|
|
6. 处理器使用解码后的数据
|
|
|
```
|
|
|
|
|
|
### 写数据流程
|
|
|
|
|
|
```
|
|
|
1. Response.Write(interface{}) → Go对象
|
|
|
↓
|
|
|
2. Codec.Encode() → []byte (序列化后的数据)
|
|
|
↓
|
|
|
3. Protocol.Encode() → []byte (添加帧头)
|
|
|
↓
|
|
|
4. Connection.Write() → 发送到客户端
|
|
|
```
|
|
|
|
|
|
## 实现状态
|
|
|
|
|
|
### ✅ 已完成
|
|
|
- [x] 接口定义（Context、Request、Response、Protocol、FrameHeader）
|
|
|
- [x] 设计文档
|
|
|
- [x] API设计文档
|
|
|
|
|
|
### 🚧 进行中
|
|
|
- [ ] Request和Response的具体实现
|
|
|
- [ ] 协议实现的更新
|
|
|
- [ ] 服务器代码的更新
|
|
|
|
|
|
### 📋 待实现
|
|
|
- [ ] 测试用例
|
|
|
- [ ] 性能优化
|
|
|
- [ ] 文档更新
|
|
|
|
|
|
## 总结
|
|
|
|
|
|
新的架构设计完全满足您的所有需求：
|
|
|
|
|
|
1. ✅ Context不包含数据读写功能
|
|
|
2. ✅ 协议帧 = 帧头（Protocol）+ 数据（Codec）
|
|
|
3. ✅ 支持连同帧头一起写入
|
|
|
4. ✅ 支持无帧头协议
|
|
|
5. ✅ 综合考虑路由、协议选择、协议版本
|
|
|
6. ✅ API设计精简、现代化
|
|
|
|
|
|
接下来可以开始实现具体的功能。
|
|
|
|