优化processor

example/GateService/GateService.go

@@ -2,19 +2,22 @@ package GateService
 
 import (
 	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/network"
+	"github.com/duanhf2012/origin/network/processor"
 	"github.com/duanhf2012/origin/node"
 	"github.com/duanhf2012/origin/service"
 	"github.com/duanhf2012/origin/sysservice"
 )
 
 type GateService struct {
-	processor *PBProcessor
 	service.Service
+	processor network.Processor
 }
 
 func (slf *GateService) OnInit() error{
 	tcpervice := node.GetService("TcpService").(*sysservice.TcpService)
-	tcpervice.SetProcessor(&PBProcessor{})
+	slf.processor = &processor.PBProcessor{}
+	tcpervice.SetProcessor(slf.processor)
 	return nil
 }
 
@@ -22,7 +25,7 @@ func (slf *GateService) OnInit() error{
 func (slf *GateService) OnEventHandler(ev *event.Event) error{
 	if ev.Type == event.Sys_Event_Tcp_RecvPack {
 		pPack := ev.Data.(*sysservice.TcpPack)
-		slf.processor.Route(pPack.Data,pPack.ClientId)
+		slf.processor.Route(ev.Data,pPack.ClientId)
 	}else if ev.Type == event.Sys_Event_Tcp_Connected {
 		pPack := ev.Data.(*sysservice.TcpPack)
 		slf.OnConnected(pPack.ClientId)

example/main.go

@@ -121,28 +121,28 @@ type Param struct {
 
 func  (slf *TestServiceCall) Run(){
 	//var ret int
-	var input int = 10000
+	//var input int = 10000
-	bT := time.Now()            // 开始时间
+	//bT := time.Now()            // 开始时间
 
 	//err := slf.Call("TestServiceCall.RPC_Test",&ret,&input)
 	var param Param
 	param.A = 2342342341
 	param.B = "xxxxxxxxxxxxxxxxxxxxxxx"
 	param.Pa = []string{"ccccc","asfsdfsdaf","bbadfsdf","ewrwefasdf","safsadfka;fksd"}
-
+	/*
 	for i:=input;i>=0;i--{
 		param.Index = i
 		slf.AsyncCall("TestService1.RPC_Test",&param, func(reply *Param, err error) {
 			if reply.Index == 0 || err != nil{
 				eT := time.Since(bT)      // 从开始到当前所消耗的时间
 				fmt.Print(err,eT.Milliseconds())
-				fmt.Print("..................",eT,"\n")
+				fmt.Print("xxxx..................",eT,err,"\n")
 			}
 			//fmt.Print(*reply,"\n",err)
 		})
 
 	}
-
+*/
 	fmt.Print("finsh....")
 
 

network/processor/pbprocessor.go

@@ -1,4 +1,4 @@
-package GateService
+package processor
 
 import (
 	"encoding/binary"
@@ -22,14 +22,14 @@ func (slf *PBProcessor) SetLittleEndian(littleEndian bool){
 	slf.LittleEndian = littleEndian
 }
 
-type PackInfo struct {
+type PBPackInfo struct {
 	typ uint16
 	msg proto.Message
 }
 
 // must goroutine safe
 func (slf *PBProcessor ) Route(msg interface{},userdata interface{}) error{
-	pPackInfo := msg.(*PackInfo)
+	pPackInfo := msg.(*PBPackInfo)
 	v,ok := slf.mapMsg[pPackInfo.typ]
 	if ok == false {
 		return fmt.Errorf("cannot find msgtype %d is register!",pPackInfo.typ)
@@ -60,7 +60,7 @@ func (slf *PBProcessor ) Unmarshal(data []byte) (interface{}, error) {
 		return nil,err
 	}
 
-	return &PackInfo{typ:msgType,msg:protoMsg},nil
+	return &PBPackInfo{typ:msgType,msg:protoMsg},nil
 }
 
 // must goroutine safe

network/processor/processor.go

@@ -1,11 +0,0 @@
-package processor
-
-type IProcessor interface {
-	//SetByteOrder(littleEndian bool)
-	//SetMsgLen(lenMsgLen int, minMsgLen uint32, maxMsgLen uint32)
-
-	Unmarshal(data []byte) (interface{}, error)
-	// must goroutine safe
-	Marshal(msg interface{}) ([][]byte, error)
-}
-

sysservice/tcpservice.go

@@ -13,11 +13,11 @@ type TcpService struct {
 	tcpServer network.TCPServer
 	service.Service
 
-	tcpService *TcpService
+	tcpService      *TcpService
 	mapClientLocker sync.RWMutex
-	mapClient map[uint64] *Client
+	mapClient       map[uint64] *Client
-	initClientId uint64
+	initClientId    uint64
-	process network.Processor
+	process         network.Processor
 }
 
 const Default_MaxConnNum = 3000