本节代码：xyq10612/PitayaGame at chapter1.3-登录逻辑与服务器路由 (github.com)

前面两节我们完成了账号注册，接下来让我们实现登录逻辑。

我们再看一下 第一节 画的架构图：

考虑 3 个问题：

1. ProxyServer 只是代理服务器，真正的登录业务逻辑（如：从数据库中加载玩家数据）是在 LobbyServer 中实现的，但是 LobbyServer 是多开的一个服务器组，代理服务器是如何知道该转发给哪个大厅服的呢？
2. 假设玩家 PlayerA 在 LobbyServer2 中登录了，由于 IO 比较慢，服务器一般会尽量少的去访问 MongoDB，所以即使玩家下线了， PlayerA 的数据也不会立刻从服务器中移除，而是会缓存一段时间。当玩家再次登录上来的时候，代理服务器将登录请求再次转发到 LobbyServer2，此时服务器上是有该玩家的缓存数据的，就不需要再去 DB 拉玩家信息了。那么 ProxyServer 是如何知道玩家之前在哪个服务器服务器登录过、保留有缓存数据呢？
3. 如果一个账号在短时间内多次登录肯定会出问题，如何实现登录锁机制、保证登录操作的原子性？

本节我们主要解决前两个问题，通过的 Session 和 Redis 来记录信息，实现 LobbyServer 的路由策略。

封装 Redis Module

既然要借助 Redis 来记录登录信息，那么我们先把操作封装一下，参考对 MongoDB 的封装，实现 DataBase 接口：
PS: 完整的代码实现在 common/modules/redis 目录

type RedisStorage struct { 	modules.Base 	*redis.Client 	config RedisConfig }  func NewRedisStorage(config RedisConfig) *RedisStorage { 	return &RedisStorage{ 		config: config, 	} }  func (r *RedisStorage) Init() error { 	r.Connect() 	return nil }  func (r *RedisStorage) Connect() { 	uri := r.config.GetConnURI() 	opts, err := redis.ParseURL(uri) 	if err != nil { 		panic(err) 	}  	r.Client = redis.NewClient(opts)  	if err := r.TestPing(); err != nil { 		panic(err) 	} }  func (r *RedisStorage) TestPing() error { 	_, err := r.Client.Ping(context.TODO()).Result() 	return err }  func (r *RedisStorage) Close() { 	_ = r.Client.Close() } 

同样的，在 common/helper/redisHelper.go 也提供一个获取 Redis 模块的方法：

var r *redis.RedisStorage  func GetRedis() *redis.RedisStorage { 	if r == nil { 		module, err := pitaya.DefaultApp.GetModule(constants.RedisModule) 		if err != nil { 			panic(err) 		}  		r = module.(*redis.RedisStorage) 	}  	return r } 

定义登录消息

message LoginRequest {   string account = 1;   string password = 2; }  message LoginResponse {   ErrCode ret = 1;   string uid = 2; } 

现在我们定义登录的回复只返回了 UID，但是实际上还需要返回其他的信息，比如：玩家的昵称、头像、等级等等。具体细节我们之后再完善，现在先聚焦于登录流程的实现。

在 LobbyServer 处理登录消息

以下 uid 的生成是临时的，但是也保证了唯一性，后面我们会使用 MongoDB 的自增 ID 来生成 UID。
顺便实现一个伪造的登录后逻辑 MockLogic，用于测试，后面我们在使用 pitaya-cli 测试的时候会用上。

// lobbyServer/service/accountService.go func (s *AccountService) Login(ctx context.Context, req *proto.LoginRequest) (*proto.LoginResponse, error) { 	logger := pitaya.GetDefaultLoggerFromCtx(ctx)  	logger.Infof("login...%v", req)  	uid := req.Account + s.app.GetServerID()[:6] 	return &proto.LoginResponse{Ret: proto.ErrCode_OK, Uid: uid}, nil }  func (s *AccountService) MockLogic(ctx context.Context) (*proto.CommonResponse, error) { 	logger := pitaya.GetDefaultLoggerFromCtx(ctx)  	logger.Infof("mock logic !")  	return &proto.CommonResponse{Err: proto.ErrCode_OK}, nil } 

在 ProxyServer 处理登录消息

回到本节一开始提出的问题，当一个玩家登录的时候，我们可以将其登录信息记录到 Redis 中，这样当玩家再次登录的时候，我们就可以通过 Redis 来判断该玩家之前是否登录过，如果登录过，就可以直接将消息转发到之前登录的服务器上。如果之前登录的服务器已经下线了，那么就随机转发到一个大厅服上，并且记录下此次登录的服务器，以便下次登录的时候使用。
再进一步思考，客户端注册的时候，与 ProxyServer 的会话已经建立起来了，注册成功时，LobbyServer 可以缓存账号信息，与登录逻辑的优化思路一致，避免过多的 IO 操作，注册之后的其他消息，也应该转发到这个 LobbyServer 上，所以我们在注册成功后，将该 LobbyServer 的 ID 绑定到会话 session上。当客户端接着发送登录消息时，可以直接从会话中获取对应的 LobbyServer ID。

将上述思路分解一下：

1. 从 session 获取上次的 lobby, 找不到就从 redis 缓存获取上次登录的 lobby
2. 没有上次登录的, 或者上次登录的 lobby 已经不存在了, 随机分配一个 lobby
3. 转发登录到 lobby, 由 lobby 处理登录逻辑, 初始化玩家数据等
4. 更新 redis 缓存, 记录登录的 lobby
5. 绑定 UID 和 lobby ID 到 Session

注册成功后，将 lobbyID 绑定到 Session

修改 Register 的实现：

func (s *AccountService) Register(ctx context.Context, req *proto.RegisterRequest) (*proto.CommonResponse, error) { 	logger := pitaya.GetDefaultLoggerFromCtx(ctx) 	session := s.app.GetSessionFromCtx(ctx)  	rsp := &proto.CommonResponse{Err: proto.ErrCode_ERR}  	lobby := router.GetRandomLobby() 	if lobby == nil { 		logger.Errorf("cannot find random lobby!") 		return rsp, nil 	}  	err := s.app.RPCTo(ctx, lobby.ID, "lobby.account.register", rsp, req) 	if err != nil { 		return nil, err 	}  	_ = session.Set(constants.SessionLobbyIdKey, lobby.ID)  	rsp.Err = proto.ErrCode_OK 	return rsp, nil } 

实现 Login，找到上次登录过的服务器

根据前面的思路分解，依次实现：

func (s *AccountService) Login(ctx context.Context, req *proto.LoginRequest) (*proto.LoginResponse, error) { 	logger := pitaya.GetDefaultLoggerFromCtx(ctx) 	session := s.app.GetSessionFromCtx(ctx)  	rsp := &proto.LoginResponse{Ret: proto.ErrCode_ERR}  	var lobbyId string  	// 1. 从session获取上次的lobby, 找不到就从redis缓存获取上次登录的lobby 	if session.HasKey(constants.SessionLobbyIdKey) { 		lobbyId = session.Get(constants.SessionLobbyIdKey).(string) 		logger.Infof("get lobby from session, account: %s", req.Account) 	} 	if lobbyId == "" { 		loginModel, err := loginModel.Get(req.Account) 		if err != nil { 			return rsp, err 		} 		lobbyId = loginModel.LobbyId 		logger.Infof("get lobby from cache, account: %s", req.Account) 	}  	// 2. 没有上次登录的, 或者上次登录的lobby已经不存在了, 随机分配一个lobby 	if lobbyId == "" || !router.IsLobbyAlive(lobbyId) { 		lobby := router.GetRandomLobby() 		if lobby == nil { 			logger.Errorf("cannot find random lobby!") 			return rsp, nil 		} 		lobbyId = lobby.ID 		logger.Infof("get lobby from random, account: %s", req.Account) 	}  	// 3. 转发登录到lobby, 由lobby处理登录逻辑, 初始化玩家数据等 	err := s.app.RPCTo(ctx, lobbyId, "lobby.account.login", rsp, req) 	if err != nil { 		logger.Errorf("rpc to lobby err: %v", err.Error()) 		rsp.Ret = proto.ErrCode_ERR 		return rsp, nil 	}  	logger = logger.WithField("userId", rsp.Uid).WithField("lobby", lobbyId)  	// 4. 更新redis缓存, 记录登录的lobby 	loginModel.Save(req.Account, lobbyId)  	// 5. 绑定session-lobby, session-uid 	session.Bind(ctx, rsp.Uid) 	session.Set(constants.SessionLobbyIdKey, lobbyId)  	logger.Infof("login success account: %s", req.Account)  	return rsp, nil } 

所以在登录成功后，Session 上就有了玩家的 UID 和 连接 上的 lobbyServer。

防止客户端绕过正常登录，直接发送消息给 LobbyServer

在第二节末尾我们说过，客户端可以直接发送消息到 lobbyServer，比如通过 lobby.account.register 来注册。这里也是一样的，可以绕过代理服务器，绕过登录逻辑，直接发送 lobbyserver.account.mocklogic 给 lobbyServer，我们测试一下看看：

尴尬了不是，别说不用登录了，账号都不要，直接可以玩游戏了，这可不行。

先搞清楚一个问题，pitaya 的前端服务器（在我们的实战项目中就是 proxyServer ）在收到一个请求时，会根据路由 URL 提取目标 ServerType 并转发。当你没有设置路由规则的时候，pitaya 会使用默认的路由规则，我们前面也提到过，默认路由规则就是返回遍历获取到的第一个服务器。
既然是这样，那我们就可以从路由规则上下功夫，定义自己的路由策略了。在上一步里，登录成功时会将玩家的 UID 和 lobbyServer ID 都绑定到了 Session，也就是说，没有绑定过的就肯定没正常登录。

捋清楚了，写代码：

// proxyServer/router/router.go func LobbyRouterFunc( 	ctx context.Context, 	route *route.Route, 	payload []byte, 	servers map[string]*cluster.Server, ) (*cluster.Server, error) { 	// 转发到绑定的 lobby 	session := pitaya.GetSessionFromCtx(ctx) 	if session == nil || !session.HasKey(constants.SessionLobbyIdKey) { 		return nil, errors.New("not find binding lobby in session") 	} 	if session.UID() == "" { 		return nil, errors.New("please login") 	}  	lobbyId := session.Get(constants.SessionLobbyIdKey).(string) 	s, ok := servers[lobbyId] 	if !ok { 		return nil, errors.New("bind lobby is not exist") 	}  	return s, nil } 

在 main 函数中，还得将路由方法注册进来：

app.AddRoute(constants.LobbyServer, router.LobbyRouterFunc) 

测试

开启 1 个 proxy 和 2 个 lobby

1. 客户端不再能绕过 proxyServer 正常的注册登录逻辑

pitaya-cli Pitaya REPL Client >>> connect 127.0.0.1:40000 Using json client connected! >>> request lobby.account.mocklogic // 不能绕过登录 >>> sv->{"code":"PIT-500","msg":"not find binding lobby in session"} >>> request lobby.account.register {"account":"test3", "password":"pwd123456"} // 不能绕过 proxy 去 lobby 注册 >>> sv->{"code":"PIT-500","msg":"not find binding lobby in session"} >>> request proxy.account.register {"account":"test3", "password":"pwd123456"} // 正常注册逻辑 >>> sv->{} >>> request lobby.account.login {"account":"test3", "password":"pwd123456"} // 不能绕过 proxy 去 lobby 登录 >>> sv->{"code":"PIT-500","msg":"please login"} >>> request proxy.account.login {"account":"test3", "password":"pwd123456"} // 正常登录逻辑 >>> sv->{"uid":"test37f5fab"} 

2. 客户端登录后，每次请求都落在了同一个 lobbyServer

发送 5 次 mocklogic 请求，都落在了同一个 lobbyServer 上

之前在 Login 成功后，proxyServer 将 UID 绑定到了 Session，这个数据会在底层被同步到后端服务器 lobbyServer，所以 MockLogic 日志打印出了 userId=xxxxxx。pitaya 框架层确实做了非常多有用的功能~！

3. 客户端断开连接后再次登录，会登录上之前的服务器，如果之前的服务器不存在，才会登录到其他还活着的服务器

这部分我就不测试了，开启两个 lobby，关闭其中一个，查看服务器日志就可以测试。
代理服务器会优先将请求分发给上次登录过的 lobby，如果之前的 lobby 不存在了，则会随机分配一个。

小结

本节我们基本实现了登录流程，完成了代理服务器对登录请求的正确路由，解决了客户端绕过代理服务器直接发送消息给 lobbyServer 的问题，但是我们还没有保证登录操作的原子性，对于高并发、高频率的登录请求，还是有可能出现问题的，这个我们会在下一节解决。

个人能力有限，如果你对本节，或者本系列，有任何疑问和建议，欢迎提出、欢迎指正，谢谢！