在Golang 游戏架构简介介绍过https://github.com/lonng/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"`
}
