go语言游戏服务端开发(三)——服务机制

2021年9月19日 19点热度 0条评论 来源: 五邑隐侠

五邑隐侠,本名关健昌,12年游戏生涯。 本教程以Go语言为例。   P2P网络为服务进程间、服务进程与客户端间通信提供了便利,在这个基础上可以搭建服务。 在服务层,通信包可以通过定义协议号来确定该包怎样处理。每个协议号对应一个Processor,Processor定义为一个interface

type Processor interface {
    OnHandleRequest(req *Request, resp *Response) (int32, error)
}

协议号又可以拆分为模块号和命令号。一个模块对应一个Service,该模块下每个命令对应一个Processor,通过map结构做映射

type Service struct {
    mapCmd2Processor map[uint16]Processor
}

Service提供方法添加、删除、获取Processor

func AddProcessor(cmd uint16, p Processor) error
func GetProcessor(cmd uint16) Processor
func RemoveProcessor(cmd uint16) error

提供个入口方法,把该模块的Service的请求分发到对应的Processor

func (s *Service) OnHandleRequest(req *Request, resp *Response) (int32, error) {
    p, ok := s.mapCmd2Processor[req.Cmd]
    if ok {
        return p.OnHandleRequest(req, resp)
    }
}

服务 Server 是 Service 的集合,通过模块号进行映射

type Server struct {
    mapMod2Service map[uint16]*Service
    rpc            *Rpc
}

同样提供方法添加、删除、获取Service

func AddService(mod uint16, srv *Service) error
func GetService(mod uint16) *Service
func RemoveService(mod uint16) error

这样当收到一个请求包,对协议号拆分为模块号和命令号,通过模块号获取到对应的Service,调用Service的 OnHandleRequest 进行处理

serv := s.GetService(req.Mod)
if serv != nil {
    code, err := serv.OnHandleRequest(req, resp)
}

Server 基于 P2P 层,P2P的包是通用的格式,不同的游戏服务端进程,都有可能有不同的包格式,例如,客户端包格式和服务内部通信的包格式是有差别的。为了让服务通用,引入服务适配器,在请求和响应时做预处理,转化为通用的 Request 和 Response

type ServerAdapter interface {
    OnRequest(payload []byte) (*Request, error)
    OnResponse(pack *Response) ([]byte, error)
}

type Server struct {
    mapMod2Service map[uint16]*Service
    rpc            *Rpc
    
    adapter        ServerAdapter
}

这样在服务层都是基于 Request 和 Response进行处理,由具体业务对业务包做转换

type Request struct {
    Mod      uint16
    Cmd      uint16
    Payload  []byte
}

type Response struct {
    Mod      uint16
    Cmd      uint16
    Payload  []byte
}

服务 Server 还可以提供拦截器,拦截器的好处是对一些阶段进行统一处理,而且可以通过插入新拦截器进行扩展,随时都可以替换这个阶段的逻辑(例如从 json 包变成 proto 包、增加二进制头等),拦截器可以针对3个阶段: 请求处理前,请求处理后,响应发送后

type Interceptor interface {
    OnPreHandle(req *Request, resp *Response) (int32, error)
    OnHandleCompletion(req *Request, resp *Response) (int32, error)
    OnResponseCompletion(req *Request, resp *Response) error
}

除了全局拦截器,还可以添加针对某个模块 Service 的拦截器,对某个 Service 做特殊拦截处理

type InterceptorList []Interceptor

type Server struct {
    mapMod2Service map[uint16]*Service
    rpc            *Rpc
    
    adapter        ServerAdapter
    globalInterceptors InterceptorList
    mapMod2Interceptors map[uint16]InterceptorList
}

这样一个请求的处理过程就变成

// adapter
req, err := s.adapter.OnRequest(payload)
resp := NewResponse(req)
// prehandle
interList, ok := s.mapMod2Interceptors[req.Mod]
s.prehandle(interList, ok, req, resp)
// handle
serv := s.GetService(req.Mod)
code, err := serv.OnHandleRequest(req, resp)
// handle complete
s.handleCompletion(interList, ok, req, resp)
s.push(resp)
// response complete
s.responseCompletion(interList, ok, req, resp)

服务机制介绍到这里,接下来聊聊 RPC 机制

 

    原文作者:五邑隐侠
    原文地址: https://www.cnblogs.com/niudanshui/p/15309838.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。