彬哥笔记 --19 Go语言 游戏服务器消息的序列化和反序列化

栏目: Go · 发布时间: 6年前

内容简介:大家好,我是彬哥,本节给大家讲下go语言服务器游戏消息的序列化相关,抛砖引玉了,主要是针对Go语言游戏服务器开发消息的序列化使用。先给大家看了小demo,LollipopGo框架版本v1.0.20190104 ,demo代码如下:LollipopGo 游戏服务器框架的部分核心代码:

大家好,我是彬哥,本节给大家讲下 go 语言服务器游戏消息的序列化相关,抛砖引玉了,主要是针对Go语言游戏服务器开发消息的序列化使用。

先给大家看了小demo,LollipopGo框架版本v1.0.20190104 ,demo代码如下:

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

/*
   Go语言中 结构体转json的序列化;在LollipopGo v1.0.20190104 版本做了详细的说明
   1 结构体转字符串
   2 字符串转json
*/

var G_GolangltdMap map[int]*GolangLtd

type GolangLtd struct {
    UID  int
    Name string
}

func init() {

    G_GolangltdMap = make(map[int]*GolangLtd)

    data := &GolangLtd{
        UID:  1,
        Name: "www.Golang.Ltd",
    }

    G_GolangltdMap[data.UID] = data

    fmt.Println(G_GolangltdMap)
    // 序列化操作
    b, er := json.Marshal(G_GolangltdMap)
    if er == nil {
        fmt.Println(string(b))
    }

    msgs := make(map[int]*GolangLtd)

    // 反序列化
    err := json.Unmarshal(b, &msgs)
    if err != nil {
        fmt.Println("Can't decode json message", err)
    } else {
        fmt.Println("type:", reflect.TypeOf(msgs[1].UID))
    }
}

func main() {
    return
}
彬哥笔记 --19 Go语言 游戏服务器消息的序列化和反序列化

运行结果

LollipopGo 游戏服务器框架的部分核心代码:

转换结构:

// 结构体数据类型
type Requestbody struct {
    req string
}

//json转化为map:数据的处理
func (r *Requestbody) Json2map() (s map[string]interface{}, err error) {
    var result map[string]interface{}
    if err := json.Unmarshal([]byte(r.req), &result); err != nil {
        glog.Error("Json2map:", err.Error())
        return nil, err
    }
    return result, nil
}

网络处理 结构:

func (this *NetDataConn) SyncMeassgeFun(content string) {
    var r Requestbody
    r.req = content

    if ProtocolData, err := r.Json2map(); err == nil {
        // 处理我们的函数
        this.HandleCltProtocol(ProtocolData["Protocol"], ProtocolData["Protocol2"], ProtocolData)
    } else {
        glog.Error("解析失败:", err.Error())
    }
}

解析的消息结构处理,主协议处理:

func (this *NetDataConn) HandleCltProtocol(protocol interface{}, protocol2 interface{}, ProtocolData map[string]interface{}) {

    defer func() { // 必须要先声明defer,否则不能捕获到panic异常
        if err := recover(); err != nil {
            strerr := fmt.Sprintf("%s", err)
            //发消息给客户端
            ErrorST := Proto2.G_Error_All{
                Protocol:  Proto.G_Error_Proto,      // 主协议
                Protocol2: Proto2.G_Error_All_Proto, // 子协议
                ErrCode:   "80006",
                ErrMsg:    "亲,您发的数据的格式不对!" + strerr,
            }
            // 发送给玩家数据
            this.PlayerSendMessage(ErrorST)
        }
    }()

    // 分发处理  --- 首先判断主协议存在,再判断子协议存在不

    //glog.Info(protocol)
    //glog.Info(Proto.GameData_Proto)

    //类型
    glog.Info(typeof(protocol))
    glog.Info(typeof(protocol2))
    //glog.Info(typeof(Proto.GameData_Proto))

    switch protocol {
    case float64(Proto.G_GateWay_Proto):
        {
            // 网关协议
            this.HandleCltProtocol2GW(protocol2, ProtocolData)
        }
    case float64(Proto.GameData_Proto):
        {
            // 子协议处理
            this.HandleCltProtocol2(protocol2, ProtocolData)

        }
    case float64(Proto.GameDataDB_Proto):
        { // DB_server

        }
    case float64(Proto.G_GameDSQ_Proto):
        { // DSQ_server
            this.HandleCltProtocol2DSQ(protocol2, ProtocolData)
        }
    case float64(Proto.G_GameGlobal_Proto):
        { // global_server
            this.HandleCltProtocol2GL(protocol2, ProtocolData)
        }
    case float64(Proto.GameNet_Proto):
        {
            this.HandleCltProtocol2Net(protocol2, ProtocolData)
        }
    case float64(Proto.G_Snake_Proto):
        { // 贪吃蛇的主协议
            fmt.Println("贪吃蛇的主协议!!!")
            this.HandleCltProtocol2Snake(protocol2, ProtocolData)

        }
    default:
        panic("主协议:不存在!!!")
    }
    return
}

子协议处理,代码如下:

// 子协议的处理
func (this *NetDataConn) HandleCltProtocol2(protocol2 interface{}, ProtocolData map[string]interface{}) {

    switch protocol2 {
    case float64(Proto2.C2S_PlayerLoginProto2):
        {
            // 功能函数处理 --  用户登陆协议
            this.PlayerLogin(ProtocolData)
        }
    case float64(Proto2.C2S_PlayerRunProto2):
        {
            // 功能函数处理 --  用户行走、奔跑
            this.PlayerRun(ProtocolData)
        }
    default:
        panic("子协议:不存在!!!")
    }

    return
}

功能函数,解析举例:

// 用户奔跑的协议
func (this *NetDataConn) PlayerRun(ProtocolData map[string]interface{}) {
    if ProtocolData["OpenID"] == nil {
        panic(" 主协议 GameData_Proto ,子协议 C2S_PlayerRunProto2,玩家行走功能数据错误!")
        return
    }

    StrOpenID := ProtocolData["OpenID"].(string)
    StrRunX := ProtocolData["StrRunX"].(string)
    StrRunY := ProtocolData["StrRunY"].(string)
    StrRunZ := ProtocolData["StrRunZ"].(string)

    // 广播协议
    data := &Proto2.S2C_PlayerRun{
        Protocol:  Proto.GameData_Proto,
        Protocol2: Proto2.S2C_PlayerRunProto2,
        OpenID:    StrOpenID,
        StrRunX:   StrRunX,
        StrRunY:   StrRunY,
        StrRunZ:   StrRunZ,
    }
    // 发送数据给客户端了
    //Broadcast(data)
    this.PlayerSendMessage(data)
    return
}

每天坚持学习1小时Go语言,大家加油,我是彬哥,下期见!如果文章中不同观点、意见请文章下留言或者关注下方订阅号反馈!

社区交流群:221273219

Golang语言社区论坛 :

www.Golang.Ltd

LollipopGo游戏服务器地址:

https://github.com/Golangltd/LollipopGo

社区视频课程课件GIT地址:

https://github.com/Golangltd/codeclass
彬哥笔记 --19 Go语言 游戏服务器消息的序列化和反序列化

Golang语言社区


以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

从规范出发的程序设计

从规范出发的程序设计

[美] Carroll Morgan / 裘宗燕 / 机械工业出版社 / 2002-8 / 45.00元

本书详细论述了有关规范程序设计的内容,包括:程序和精化、谓词演算、选择、迭代、构造类型、模块和封装等,最后几章还包含了大量的实例研究和一些更高级的程序设计技术。本书提倡一种严格的程序开发方法,分析问题要用严格方式写出程序的规范,而后通过一系列具有严格理论基础的推导,最终得到可以运行的程序。 本书是被世界上许多重要大学采用的教材,适于计算机及相关专业的本科生和研究生使用。一起来看看 《从规范出发的程序设计》 这本书的介绍吧!

RGB转16进制工具
RGB转16进制工具

RGB HEX 互转工具

XML、JSON 在线转换
XML、JSON 在线转换

在线XML、JSON转换工具

UNIX 时间戳转换
UNIX 时间戳转换

UNIX 时间戳转换