Golang 游戏nano简介

在Golang 游戏架构简介介绍过https://github.com/lonng/nano，本文通过官方提供的聊天室例子，简要学习一下。

参考如何构建你的第一个nano应用

在这个教程中，我们将构建一个基于浏览器和WebSocket的聊天应用。本教程的示例源码放在github上完整代码

由于游戏在场景管理、客户端动画等方面有一定的复杂性，并不适合作为nano的入门应用。对于大多数开发者而言，普通聊天室是一个更加适合入门nano的应用。

nano是一个轻量级的服务器框架，它最适合的应用领域是网页游戏、社交游戏、移动游戏的服务端。当然还不仅仅是游戏，用nano开发高实时web应用也非常合适。

一、术语解释

1.组件(Component)

nano应用是由一些松散耦合的Component组成的，每个Component完成一些功能。整个应用可以看作是一个Component容器，完成Component的加载以及生命周期管理。每个Component往往有Init，AfterInit， BeforeShutdown，Shutdown等方法，用来完成生命周期管理。

type DemoComponent struct{}

func (c *DemoComponent) Init()           {}
func (c *DemoComponent) AfterInit()      {}
func (c *DemoComponent) BeforeShutdown() {}
func (c *DemoComponent) Shutdown()       {}

2.Handler

Handler用来处理业务逻辑，Handler可以有如下形式的签名：

// 以下的Handler会自动将消息反序列化，在调用时当做参数传进来
func (c *DemoComponent) DemoHandler(s *session.Session, payload *pb.DemoPayload) error {
    // 业务逻辑开始
    // ...
    // 业务逻辑结束

    return nil
}

// 以下的Handler不会自动将消息反序列化，会将客户端发送过来的消息直接当作参数传进来
func (c *DemoComponent) DemoHandler(s *session.Session, raw []byte) error {
    // 业务逻辑开始
    // ...
    // 业务逻辑结束

    return nil
}

3.路由(Route)

route用来标识一个具体服务或者客户端接受服务端推送消息的位置，对服务端来说，其形式一般是..,例如 "Room.Message", 在我们的示例中, Room是一个包含相关Handler的组件, Message是一个定义在 Room中的Handler, Room中所有符合Handler签名的方法都会在nano应用启动时自动注册.

对客户端来说，其路由一般形式为onXXX(比如我们示例中的onMessage)，当服务端推送消息时，客户端会有相应的回调。

4.会话(Session)

Session对应于一个客户端会话, 当客户端连接服务器后, 会建立一个会话, 会话在玩家保持连接期间可以用于保存一些上下文信息, 这些信息会在连接断开后释放.

5.组(Group)

Group可以看作是一个Session的容器，主要用于需要广播推送消息的场景。可以把某个玩家的Session加入到一个Group中，当对这个Group推送消息的时候，所有加入到这个Group的玩家都会收到推送过来的消息。一个玩家的Session可能会被加入到多个Group中，这样玩家就会收到其加入的Group推送过来的消息。

5.请求(Request), 响应(Response), 通知(Notify), 推送(Push)

nano中有四种消息类型的消息，分别是请求(Request), 响应(Response), 通知(Notify)和推送(Push)。

客户端发起Request到服务器端，服务器端处理后会给其返回响应Response;
Notify是客户端发给服务端的通知，也就是不需要服务端给予回复的请求;
Push是服务端主动给客户端推送消息的类型。

三、代码实例

先看部分前端代码：

var v = new Vue({
    el: "#container",
    data: {
        nickname:'guest' + Date.now(),
        inputMessage:'',
        messages: []
    },
    methods: {
        sendMessage: function () {
            console.log(this.inputMessage);
            starx.notify('room.message', {name: this.nickname, content: this.inputMessage});
            this.inputMessage = '';
        }
    }
});

var onMessage = function (msg) {
    v.messages.push(msg)
};

var join = function (data) {
    console.log("join",data);
    if(data.code === 0) {
        v.messages.push({name:'system', content:'join:'+data.result});
        starx.on('onMessage', onMessage)
    }
};

var onNewUser = function (data) {
    console.log('onNewUser:',data);
    v.messages.push({name:'system', content:'onNewUser:'+data.content});
};

var onMembers = function (data) {
    console.log("onMembers:",data);
    v.messages.push({name:'system', content: "onMembers: "+data.members});
};

starx.init({host: '127.0.0.1', port: 3250, path: '/nano'}, function () {
    console.log("initialized");
    starx.on("onNewUser", onNewUser);
    starx.on("onMembers", onMembers);
    starx.request("room.join", {}, join);
})

1.前端的starx.init

这里会响应两个服务端消息onNewUser,onMembers。然后主动使用request发送了一个room.join消息，并且回调是join方法。由上面概念得知，request会得到一个response:

// JoinResponse represents the result of joining room
JoinResponse struct {
    Code   int    `json:"code"`
    Result string `json:"result"`
}

// Join room
func (mgr *RoomManager) Join(s *session.Session, msg []byte) error {
    ...
    return s.Response(&JoinResponse{Result: "success"})
}

Join方法满足Handler签名方法，自动注册到RoomManager了。返回一个Response也很简单，自动序列化了。在前端的join方法中，判断如果连接成功，会接着侦听onMessage方法。注意，这几个方法都是name,content的数据格式。服务端的msg会自动序列化：

// UserMessage represents a message that user sent
UserMessage struct {
    Name    string `json:"name"`
    Content string `json:"content"`
}

2.后端的main

func main() {
    // override default serializer
    nano.SetSerializer(json.NewSerializer())

    // rewrite component and handler name
    room := NewRoomManager()
    nano.Register(room,
        component.WithName("room"),
        component.WithNameFunc(strings.ToLower),
    )
    ...
}

func NewRoomManager() *RoomManager {
    return &RoomManager{
        rooms: map[int]*Room{},
    }
}

Room struct {
    group *nano.Group
}

// RoomManager represents a component that contains a bundle of room
RoomManager struct {
    component.Base
    timer *nano.Timer
    rooms map[int]*Room
}

3.RoomManager

const (
    testRoomID = 1
    roomIDKey  = "ROOM_ID"
)

func NewRoomManager() *RoomManager {
    return &RoomManager{
        rooms: map[int]*Room{},
    }
}

// AfterInit component lifetime callback
func (mgr *RoomManager) AfterInit() {
    session.Lifetime.OnClosed(func(s *session.Session) {
        if !s.HasKey(roomIDKey) {
            return
        }
        room := s.Value(roomIDKey).(*Room)
        room.group.Leave(s)
    })
    mgr.timer = nano.NewTimer(time.Minute, func() {
        for roomId, room := range mgr.rooms {
            println(fmt.Sprintf("UserCount: RoomID=%d, Time=%s, Count=%d",
                roomId, time.Now().String(), room.group.Count()))
        }
    })
}

这里AfterInit中，当一个session关闭时，把它从group中移除。rooms是个映射，本例子中只用了testRoomID这个key

// Join room
func (mgr *RoomManager) Join(s *session.Session, msg []byte) error {
    // NOTE: join test room only in demo
    room, found := mgr.rooms[testRoomID]
    if !found {
        room = &Room{
            group: nano.NewGroup(fmt.Sprintf("room-%d", testRoomID)),
        }
        mgr.rooms[testRoomID] = room
    }

    fakeUID := s.ID() //just use s.ID as uid !!!
    s.Bind(fakeUID)   // binding session uids.Set(roomIDKey, room)
    s.Set(roomIDKey, room)
    s.Push("onMembers", &AllMembers{Members: room.group.Members()})
    // notify others
    room.group.Broadcast("onNewUser", &NewUser{Content: fmt.Sprintf("New user: %d", s.ID())})
    // new user join group
    room.group.Add(s) // add session to group
    return s.Response(&JoinResponse{Result: "success"})
}

Join时判断一下，如果没有testRoomID这个Room，则创建一个。然后就是一个Push,一个Broadcast，紧接着一个Response。注意group在Broadcast onNewUser之后，才添加新成员。session通过s.Set(roomIDKey, room)和Room进行了关联。然后响应消息：

// Message sync last message to all members
func (mgr *RoomManager) Message(s *session.Session, msg *UserMessage) error {
    if !s.HasKey(roomIDKey) {
        return fmt.Errorf("not join room yet")
    }
    room := s.Value(roomIDKey).(*Room)
    return room.group.Broadcast("onMessage", msg)
}

ID都是int64类型的:

// AllMembers contains all members uid
AllMembers struct {
    Members []int64 `json:"members"`
}