优化工程结构

2026-06-11 07:46:50 +08:00 · 2020-10-30 16:32:37 +08:00
parent 3025eaebd5
commit d2f52b382d
33 changed files with 1087 additions and 1210 deletions
--- a/sysservice/tcpgateway/GateProxyModule.go
+++ b/sysservice/tcpgateway/GateProxyModule.go
@@ -16,7 +16,7 @@ func NewGateProxyModule() *GateProxyModule{
 	return &GateProxyModule{defaultGateRpc:"TcpGateService.RPC_Dispatch"}
 }

-func (slf *GateProxyModule) Send(clientId interface{},msgType uint16,msg proto.Message) error {
+func (gate *GateProxyModule) Send(clientId interface{},msgType uint16,msg proto.Message) error {
 	//对agentId进行分组
 	mapNodeClientId := map[int][]uint64{}
 	switch clientId.(type) {
@@ -41,7 +41,6 @@ func (slf *GateProxyModule) Send(clientId interface{},msgType uint16,msg proto.M
 	replyMsg.MsgType = proto.Uint32(uint32(msgType))
 	replyMsg.Msg = bData

-
 	for nodeId,clientIdList := range mapNodeClientId {
 		if nodeId <0 || nodeId>tcpservice.MaxNodeId {
 			fmt.Errorf("nodeid is error %d",nodeId)
@@ -49,20 +48,17 @@ func (slf *GateProxyModule) Send(clientId interface{},msgType uint16,msg proto.M
 		}

 		replyMsg.ClientList = clientIdList
-		slf.GetService().GetRpcHandler().GoNode(nodeId,slf.defaultGateRpc,&replyMsg)
+		gate.GetService().GetRpcHandler().GoNode(nodeId,gate.defaultGateRpc,&replyMsg)
 	}

 	return nil
 }

-
-
-func (slf *GateProxyModule) SetDefaultGateRpcMethodName(rpcMethodName string){
-	slf.defaultGateRpc = rpcMethodName
+func (gate *GateProxyModule) SetDefaultGateRpcMethodName(rpcMethodName string){
+	gate.defaultGateRpc = rpcMethodName
 }

-
-func (slf *GateProxyModule) send(clientId uint64,msgType uint16,msg []byte) error {
+func (gate *GateProxyModule) send(clientId uint64,msgType uint16,msg []byte) error {
 	nodeId := tcpservice.GetNodeId(clientId)
 	if nodeId <0 || nodeId>tcpservice.MaxNodeId {
 		return fmt.Errorf("nodeid is error %d",nodeId)
@@ -73,5 +69,5 @@ func (slf *GateProxyModule) send(clientId uint64,msgType uint16,msg []byte) erro
 	replyMsg.Msg = msg
 	replyMsg.ClientList = append(replyMsg.ClientList ,clientId)

-	return slf.GetService().GetRpcHandler().GoNode(nodeId,slf.defaultGateRpc,&replyMsg)
+	return gate.GetService().GetRpcHandler().GoNode(nodeId, gate.defaultGateRpc,&replyMsg)
 }
--- a/sysservice/tcpgateway/LoadBalance.go
+++ b/sysservice/tcpgateway/LoadBalance.go
@@ -3,6 +3,6 @@ package tcpgateway
 type LoadBalance struct {
 }

-func (slf *LoadBalance) SelectNode(serviceName string) int {
+func (balance *LoadBalance) SelectNode(serviceName string) int {
 	return 1
 }
--- a/sysservice/tcpgateway/Router.go
+++ b/sysservice/tcpgateway/Router.go
@@ -46,9 +46,9 @@ func NewRouter(loadBalance ILoadBalance,rpcHandler rpc.IRpcHandler,cfg interface
 	return router
 }

-func (slf *Router) loadCfg(cfg interface{}){
-	slf.mapMsgRouterInfo = map[uint16]*MsgRouterInfo{}
-	slf.mapEventRouterInfo = map[string]*EventRouterInfo{}
+func (r *Router) loadCfg(cfg interface{}){
+	r.mapMsgRouterInfo = map[uint16]*MsgRouterInfo{}
+	r.mapEventRouterInfo = map[string]*EventRouterInfo{}

 	mapRouter,ok := cfg.(map[string]interface{})
 	if ok == false{
@@ -100,7 +100,7 @@ func (slf *Router) loadCfg(cfg interface{}){
 			continue
 		}

-		slf.mapMsgRouterInfo[uint16(msgId)] = &MsgRouterInfo{ServiceName:strService[0],Rpc: iRpc.(string),LoadBalanceType: iLoadBalanceType.(string)}
+		r.mapMsgRouterInfo[uint16(msgId)] = &MsgRouterInfo{ServiceName: strService[0],Rpc: iRpc.(string),LoadBalanceType: iLoadBalanceType.(string)}
 	}

 	//parse EventRouter
@@ -147,12 +147,12 @@ func (slf *Router) loadCfg(cfg interface{}){
 			continue
 		}

-		slf.mapEventRouterInfo[strEventType] = &EventRouterInfo{ServiceName:strService[0],Rpc: iRpc.(string),LoadBalanceType: iLoadBalanceType.(string)}
+		r.mapEventRouterInfo[strEventType] = &EventRouterInfo{ServiceName: strService[0],Rpc: iRpc.(string),LoadBalanceType: iLoadBalanceType.(string)}
 	}
 }

-func (slf *Router) GetMsgRouterService(msgType uint16) *MsgRouterInfo{
-	info,ok := slf.mapMsgRouterInfo[msgType]
+func (r *Router) GetMsgRouterService(msgType uint16) *MsgRouterInfo{
+	info,ok := r.mapMsgRouterInfo[msgType]
 	if ok == false {
 		return nil
 	}
@@ -160,8 +160,8 @@ func (slf *Router) GetMsgRouterService(msgType uint16) *MsgRouterInfo{
 	return info
 }

-func (slf *Router) GetEventRouterService(eventType string) *EventRouterInfo{
-	info,ok := slf.mapEventRouterInfo[eventType]
+func (r *Router) GetEventRouterService(eventType string) *EventRouterInfo{
+	info,ok := r.mapEventRouterInfo[eventType]
 	if ok == false {
 		return nil
 	}
@@ -169,8 +169,8 @@ func (slf *Router) GetEventRouterService(eventType string) *EventRouterInfo{
 	return info
 }

-func (slf *Router) GetRouterId(clientId uint64,serviceName *string) int {
-	mapServiceRouter,ok := slf.mapClientRouterCache[clientId]
+func (r *Router) GetRouterId(clientId uint64,serviceName *string) int {
+	mapServiceRouter,ok := r.mapClientRouterCache[clientId]
 	if ok == false{
 		return 0
 	}
@@ -183,46 +183,46 @@ func (slf *Router) GetRouterId(clientId uint64,serviceName *string) int {
 	return routerId
 }

-func (slf *Router) SetRouterId(clientId uint64,serviceName *string,routerId int){
-	slf.mapClientRouterCache[clientId][*serviceName] = routerId
+func (r *Router) SetRouterId(clientId uint64,serviceName *string,routerId int){
+	r.mapClientRouterCache[clientId][*serviceName] = routerId
 }

-func (slf *Router) RouterMessage(clientId uint64,msgType uint16,msg []byte) {
-	routerInfo:= slf.GetMsgRouterService(msgType)
+func (r *Router) RouterMessage(clientId uint64,msgType uint16,msg []byte) {
+	routerInfo:= r.GetMsgRouterService(msgType)
 	if routerInfo==nil {
 		log.Error("The message type is %d with no configured route!",msgType)
 		return
 	}

-	routerId := slf.GetRouterId(clientId,&routerInfo.ServiceName)
+	routerId := r.GetRouterId(clientId,&routerInfo.ServiceName)
 	if routerId ==0 {
-		routerId = slf.loadBalance.SelectNode(routerInfo.ServiceName)
-		slf.SetRouterId(clientId,&routerInfo.ServiceName,routerId)
+		routerId = r.loadBalance.SelectNode(routerInfo.ServiceName)
+		r.SetRouterId(clientId,&routerInfo.ServiceName,routerId)
 	}

 	if routerId>0 {
-		slf.rpcHandler.RawGoNode(rpc.RPC_PROCESSOR_PB,routerId,routerInfo.Rpc,msg,proto.Uint64(clientId))
+		r.rpcHandler.RawGoNode(rpc.RpcProcessorPb,routerId,routerInfo.Rpc,msg,proto.Uint64(clientId))
 	}
 }

-func (slf *Router) Load(){
+func (r *Router) Load(){
 }

-func (slf *Router) RouterEvent(clientId uint64,eventType string) bool{
-	routerInfo:= slf.GetEventRouterService(eventType)
+func (r *Router) RouterEvent(clientId uint64,eventType string) bool{
+	routerInfo:= r.GetEventRouterService(eventType)
 	if routerInfo==nil {
 		log.Error("The event type is %s with no register!",eventType)
 		return false
 	}

-	routerId := slf.GetRouterId(clientId,&routerInfo.ServiceName)
+	routerId := r.GetRouterId(clientId,&routerInfo.ServiceName)
 	if routerId ==0 {
-		routerId = slf.loadBalance.SelectNode(routerInfo.ServiceName)
-		slf.SetRouterId(clientId,&routerInfo.ServiceName,routerId)
+		routerId = r.loadBalance.SelectNode(routerInfo.ServiceName)
+		r.SetRouterId(clientId,&routerInfo.ServiceName,routerId)
 	}

 	if routerId>0 {
-		slf.rpcHandler.RawGoNode(rpc.RPC_PROCESSOR_PB,routerId,routerInfo.Rpc,[]byte{},proto.Uint64(clientId))
+		r.rpcHandler.RawGoNode(rpc.RpcProcessorPb,routerId,routerInfo.Rpc,[]byte{},proto.Uint64(clientId))
 		return true
 	}

@@ -230,13 +230,13 @@ func (slf *Router) RouterEvent(clientId uint64,eventType string) bool{
 }


-func (slf *Router) OnDisconnected(clientId uint64){
-	delete(slf.mapClientRouterCache,clientId)
+func (r *Router) OnDisconnected(clientId uint64){
+	delete(r.mapClientRouterCache,clientId)
 	//通知事件
-	slf.RouterEvent(clientId,"DisConnect")
+	r.RouterEvent(clientId,"DisConnect")
 }

-func (slf *Router) OnConnected(clientId uint64){
-	slf.mapClientRouterCache[clientId] = map[string]int{}
-	slf.RouterEvent(clientId,"Connect")
+func (r *Router) OnConnected(clientId uint64){
+	r.mapClientRouterCache[clientId] = map[string]int{}
+	r.RouterEvent(clientId,"Connect")
 }
--- a/sysservice/tcpgateway/TcpGateService.go
+++ b/sysservice/tcpgateway/TcpGateService.go
@@ -23,76 +23,75 @@ type TcpGateService struct {

 	processor processor.IRawProcessor
 	tcpService *tcpservice.TcpService
-
 	loadBalance ILoadBalance
 	router IRouter
 }


-func (slf *TcpGateService) OnInit() error {
-	slf.OnLoad()
+func (gateService *TcpGateService) OnInit() error {
+	gateService.OnLoad()

 	//注册监听客户连接断开事件
-	slf.processor.SetDisConnectedHandler(slf.router.OnDisconnected)
+	gateService.processor.SetDisConnectedHandler(gateService.router.OnDisconnected)
 	//注册监听客户连接事件
-	slf.processor.SetConnectedHandler(slf.router.OnConnected)
+	gateService.processor.SetConnectedHandler(gateService.router.OnConnected)

 	//注册监听消息类型MsgType_MsgReq，并注册回调
-	slf.processor.SetRawMsgHandler(slf.router.RouterMessage)
+	gateService.processor.SetRawMsgHandler(gateService.router.RouterMessage)
 	//将protobuf消息处理器设置到TcpService服务中
-	slf.tcpService.SetProcessor(slf.processor,slf.GetEventHandler())
+	gateService.tcpService.SetProcessor(gateService.processor, gateService.GetEventHandler())
 	
 	return nil
 }

-func (slf *TcpGateService) OnLoad() {
+func (gateService *TcpGateService) OnLoad() {
 	//设置默认LoadBalance
-	if slf.loadBalance == nil {
-		slf.loadBalance = &LoadBalance{}
+	if gateService.loadBalance == nil {
+		gateService.loadBalance = &LoadBalance{}
 	}

 	//设置默认Router
-	if slf.router == nil {
-		slf.router = NewRouter(slf.loadBalance,slf,slf.GetServiceCfg())
+	if gateService.router == nil {
+		gateService.router = NewRouter(gateService.loadBalance, gateService, gateService.GetServiceCfg())
 	}

 	//新建内置的protobuf处理器，您也可以自定义路由器，比如json
-	if slf.processor == nil {
-		slf.processor = processor.NewPBRawProcessor()
+	if gateService.processor == nil {
+		gateService.processor = processor.NewPBRawProcessor()
 	}

 	//加载路由
-	slf.router.Load()
+	gateService.router.Load()

 	//设置默认的TcpService服务
-	if slf.tcpService == nil {
-		slf.tcpService =  node.GetService("TcpService").(*tcpservice.TcpService)
+	if gateService.tcpService == nil {
+		gateService.tcpService =  node.GetService("TcpService").(*tcpservice.TcpService)
 	}

-	if slf.tcpService == nil {
+	if gateService.tcpService == nil {
 		panic("TcpService is not installed!")
 	}
 }

-func (slf *TcpGateService) SetLoadBalance(loadBalance ILoadBalance){
-	slf.loadBalance = loadBalance
+func (gateService *TcpGateService) SetLoadBalance(loadBalance ILoadBalance){
+	gateService.loadBalance = loadBalance
 }

-func (slf *TcpGateService) SetRouter(router IRouter){
-	slf.router = router
+func (gateService *TcpGateService) SetRouter(router IRouter){
+	gateService.router = router
 }

-func (slf *TcpGateService) SetRawProcessor(processor processor.IRawProcessor){
-	slf.processor = processor
+func (gateService *TcpGateService) SetRawProcessor(processor processor.IRawProcessor){
+	gateService.processor = processor
 }

-func (slf *TcpGateService) SetTcpGateService(tcpService *tcpservice.TcpService){
-	slf.tcpService = tcpService
+func (gateService *TcpGateService) SetTcpGateService(tcpService *tcpservice.TcpService){
+	gateService.tcpService = tcpService
 }

-func (slf *TcpGateService) RPC_Dispatch(replyMsg *ReplyMessage) error {
+func (gateService *TcpGateService) RPC_Dispatch(replyMsg *ReplyMessage) error {
 	for _,id := range replyMsg.ClientList {
-		err := slf.tcpService.SendRawMsg(id,replyMsg.Msg)
+		err := gateService.tcpService.SendRawMsg(id,replyMsg.Msg)
 		if err != nil {
 			log.Debug("SendRawMsg fail:%+v!",err)
 		}