Go语言实现长连接并发框架 - 请求分发器

前言

你好，我是醉墨居士，我们上篇博客实现了任务管理器的功能，接下来这篇博客我们将要实现请求分发模块的开发

接口

trait/dispatcher.go

type Dispatcher interface {
Start()
Dispatch(connQueue chan Connection)
BatchDispatch(conn Connection) error
SetHeaderDeadline(deadline time.Time)
SetBodyDeadline(deadline time.Time)
ChooseQueue(conn Connection) chan <- Connection
Commit(conn Connection)
}

结构体

gcore/dispatcher.go

// Dispatcher 请求分发模块，负责读取客户端连接的数据，并对数据进行拆包转换成消息格式，然后分发给下游的任务处理模块对消息进行业务处理
type Dispatcher struct {
headerDeadline time.Time
bodyDeadline time.Time

connQueue []chan trait.Connection
taskMgr trait.TaskMgr
}

// NewDispatcher 创建一个请求分发器
func NewDispatcher(taskMgr trait.TaskMgr) *Dispatcher {
connQueue := make([]chan trait.Connection, global.Config.DispatcherQueues)
for i := 0; i < len(connQueue); i++ {
connQueue[i] = make(chan trait.Connection, global.Config.DispatcherQueueLen)
}

return &Dispatcher{
connQueue: connQueue,
taskMgr: taskMgr,
}
}

接口实现

gcore/dispatcher.go

// Start 启动请求分发模块
func (d *Dispatcher) Start() {
for i := 0; i < len(d.connQueue); i++ {
for j := 0; j < global.Config.DispatcherQueueLen; j++ {
go d.Dispatch(d.connQueue[i])
}
}
}

// StartDispatcher 分发连接数据
func (d *Dispatcher) Dispatch(connQueue chan trait.Connection) {
// 从conn中读取数据，并将数据提交给taskMgr处理
for conn := range connQueue {
d.BatchDispatch(conn)
}
}

// BatchDispatch 批量读取连接中的数据，并封装成请求，然后分发请求
func (d *Dispatcher) BatchDispatch(conn trait.Connection) error {
for time.Now().After(d.headerDeadline) {
header := make([]byte, 4)

// 设置header读取超时时间
conn.SetReadDeadline(d.headerDeadline)

_, err := io.ReadFull(conn, header)
if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
// 数据包读取超时
return nil
}

return err
}

// 设置body读取超时时间
conn.SetReadDeadline(d.bodyDeadline)

// 读取长度
dataLen := binary.BigEndian.Uint16(header[2:4])
// 读取数据
body := make([]byte, dataLen)
_, err = io.ReadFull(conn, body)
if err != nil {
return err
}

msg := gpack.Unpack(header, body)
// 提交消息，处理数据

request := NewRequest(conn, msg)

d.taskMgr.Submit(request)
}

return nil
}

// SetHeaderDeadline 设置header读取超时时间
func (d *Dispatcher) SetHeaderDeadline(deadline time.Time) {
d.headerDeadline = deadline
}

// SetBodyDeadline 设置body读取超时时间
func (d *Dispatcher) SetBodyDeadline(deadline time.Time) {
d.bodyDeadline = deadline
}

// ChooseQueue 选择处理连接的队列
func (d *Dispatcher) ChooseQueue(conn trait.Connection) chan <- trait.Connection {
// 负载均衡，选择队列
return d.connQueue[conn.ID() % int32(len(d.connQueue))]
}

// Commit 提交连接到队列
func (d *Dispatcher) Commit(conn trait.Connection) {
d.ChooseQueue(conn) <- conn
}

项目地址

Github：https://github.com/zm50/gte
Giee：https://gitee.com/zm50/gte

最后

我是醉墨居士，我们完成了基本的请求分发器的开发，希望对你有所帮助，也希望你有所收获

原文地址：https://blog.csdn.net/qq_67733273/article/details/142692939

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！