优化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/GateService/pbprocessor.go

@@ -1,79 +0,0 @@
-package GateService
-
-import (
-	"encoding/binary"
-	"fmt"
-	"github.com/golang/protobuf/proto"
-	"reflect"
-)
-
-type MessageInfo struct {
-	msgType    reflect.Type
-	msgHandler MessageHandler
-}
-
-
-type PBProcessor struct {
-	mapMsg map[uint16]MessageInfo
-	LittleEndian bool
-}
-
-func (slf *PBProcessor) SetLittleEndian(littleEndian bool){
-	slf.LittleEndian = littleEndian
-}
-
-type PackInfo struct {
-	typ uint16
-	msg proto.Message
-}
-
-// must goroutine safe
-func (slf *PBProcessor ) Route(msg interface{},userdata interface{}) error{
-	pPackInfo := msg.(*PackInfo)
-	v,ok := slf.mapMsg[pPackInfo.typ]
-	if ok == false {
-		return fmt.Errorf("cannot find msgtype %d is register!",pPackInfo.typ)
-	}
-
-
-	v.msgHandler(userdata.(uint64),pPackInfo.msg)
-	return nil
-}
-
-// must goroutine safe
-func (slf *PBProcessor ) Unmarshal(data []byte) (interface{}, error) {
-	var msgType uint16
-	if slf.LittleEndian == true {
-		msgType = binary.LittleEndian.Uint16(data[:2])
-	}else{
-		msgType = binary.BigEndian.Uint16(data[:2])
-	}
-
-	info,ok := slf.mapMsg[msgType]
-	if ok == false {
-		return nil,fmt.Errorf("cannot find register %d msgtype!",msgType)
-	}
-	msg := reflect.New(info.msgType.Elem()).Interface()
-	protoMsg := msg.(proto.Message)
-	err := proto.Unmarshal(data[2:], protoMsg)
-	if err != nil {
-		return nil,err
-	}
-
-	return &PackInfo{typ:msgType,msg:protoMsg},nil
-}
-
-// must goroutine safe
-func (slf *PBProcessor ) Marshal(msg interface{}) ([]byte, error){
-	return proto.Marshal(msg.(proto.Message))
-}
-
-type MessageHandler func(clientid uint64,msg proto.Message)
-
-func (slf *PBProcessor) Register(msgtype uint16,msg proto.Message,handle MessageHandler)  {
-	var info MessageInfo
-
-	info.msgType = reflect.TypeOf(msg.(proto.Message))
-	info.msgHandler = handle
-	slf.mapMsg[msgtype] = info
-}

example/main.go

@@ -121,28 +121,28 @@ type Param struct {
 
 func  (slf *TestServiceCall) Run(){
 	//var ret int
-	var input int = 10000
-	bT := time.Now()            // 开始时间
+	//var input int = 10000
+	//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....")