自定义rpc错误类型

example/main.go

@@ -136,7 +136,7 @@ func (slf *TestServiceCall) Test(){
 
 func  (slf *TestServiceCall) Run(){
 	//var ret int
-	var input int = 1000000
+	var input int = 1
 	//bT := time.Now()            // 开始时间
 
 	//err := slf.Call("TestServiceCall.RPC_Test",&ret,&input)
@@ -149,9 +149,12 @@ func  (slf *TestServiceCall) Run(){
 		if param.Index == 0 {
 			fmt.Print(".......................\n")
 		}
-		slf.AsyncCall("TestService1.RPC_Test",&param, func(reply *Param, err error) {
+		err := slf.AsyncCall("TestService1.RPC_Test",&param, func(reply *Param, err error) {
 			log.Debug(" index %d ,err %+v",reply.Index,err)
 		})
+		if err != nil {
+			fmt.Printf("x333333333333:%+v",err)
+		}
 
 	}
 
@@ -167,13 +170,13 @@ func (slf *TestService1) RPC_Test(a *Param,b *Param) error {
 func (slf *TestService1) OnInit() error {
 	return nil
 }
-
+/*
 func (slf *TestServiceCall) RPC_Test(a *int,b *int) error {
 	fmt.Printf("TestService2\n")
 	*a = *b
 	return nil
 }
-
+*/
 func (slf *TestServiceCall) TestDB() {
 	assetsInfo := &struct {
 		Cash  int64 `json:"cash"`  //美金余额 100

rpc/client.go

@@ -130,7 +130,7 @@ func (slf *Client) Go(noReply bool,mutiCoroutine bool,serviceMethod string, args
 	return call
 }
 
-type RequestHandler func(Returns interface{},Err error)
+type RequestHandler func(Returns interface{},Err *RpcError)
 
 type RpcRequest struct {
 	//packhead
@@ -151,7 +151,7 @@ type RpcRequest struct {
 type RpcResponse struct {
 	//head
 	Seq           uint64   // sequence number chosen by client
-	Err error
+	Err *RpcError
 
 	//returns
 	Returns []byte
@@ -189,6 +189,9 @@ func (slf *Client) Run(){
 					v.Err = err
 				}
 			}
+			if respone.Err != nil {
+				v.Err= respone.Err
+			}
 
 
 			if v.callback.IsValid() {

rpc/rpchandler.go

@@ -13,6 +13,31 @@ type FuncRpcClient func(nodeid int,serviceMethod string) ([]*Client,error)
 type FuncRpcServer func() (*Server)
 var NilError = reflect.Zero(reflect.TypeOf((*error)(nil)).Elem())
 
+type RpcError struct {
+	Err string
+}
+
+func (slf *RpcError) Error() string {
+	return slf.Err
+}
+
+func NewRpcError(e string) *RpcError {
+	return &RpcError{Err:e}
+}
+
+func ConvertError(e error) *RpcError{
+	if e == nil {
+		return nil
+	}
+
+	return &RpcError{Err:e.Error()}
+}
+
+func Errorf(format string, a ...interface{}) *RpcError {
+	return NewRpcError(fmt.Sprintf(format,a...))
+}
+
+
 type RpcMethodInfo struct {
 	method reflect.Method
 	iparam interface{}
@@ -157,10 +182,11 @@ func (slf *RpcHandler) HandlerRpcResponeCB(call *Call){
 
 }
 
+
 func (slf *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	v,ok := slf.mapfunctons[request.ServiceMethod]
 	if ok == false {
-		err := fmt.Errorf("RpcHandler %s cannot find %s",slf.rpcHandler.GetName(),request.ServiceMethod)
+		err := Errorf("RpcHandler %s cannot find %s",slf.rpcHandler.GetName(),request.ServiceMethod)
 		log.Error("%s",err.Error())
 		if request.requestHandle!=nil {
 			request.requestHandle(nil,err)
@@ -174,7 +200,7 @@ func (slf *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	if request.localParam==nil{
 		err = processor.Unmarshal(request.InParam,&v.iparam)
 		if err!=nil {
-			rerr := fmt.Errorf("Call Rpc %s Param error %+v",request.ServiceMethod,err)
+			rerr := Errorf("Call Rpc %s Param error %+v",request.ServiceMethod,err)
 			log.Error("%s",rerr.Error())
 			if request.requestHandle!=nil {
 				request.requestHandle(nil, rerr)
@@ -199,7 +225,7 @@ func (slf *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	}
 
 	if request.requestHandle!=nil {
-		request.requestHandle(oParam.Interface(), err)
+		request.requestHandle(oParam.Interface(), ConvertError(err))
 	}
 }
 

rpc/server.go

@@ -120,15 +120,19 @@ func (agent *RpcAgent) Run() {
 			continue
 		}
 		if req.NoReply == false {
-			req.requestHandle = func(Returns interface{},Err error){
+			req.requestHandle = func(Returns interface{},Err *RpcError){
 				var rpcRespone RpcResponse
 				rpcRespone.Seq = req.Seq
 				rpcRespone.Err = Err
 				if Err==nil {
-					rpcRespone.Returns,rpcRespone.Err = processor.Marshal(Returns)
+					rpcRespone.Returns,err = processor.Marshal(Returns)
+					if err!= nil {
+						rpcRespone.Err = ConvertError(err)
+					}
+					//rpcRespone.Returns, = processor.Marshal(Returns)
 				}
 
-				bytes,err :=  processor.Marshal(rpcRespone)
+				bytes,err :=  processor.Marshal(&rpcRespone)
 				if err != nil {
 					log.Error("service method %s Marshal error:%+v!", req.ServiceMethod,err)
 					return
@@ -208,7 +212,7 @@ func (slf *Server) rpcHandlerGo(noReply bool,mutiCoroutine bool,handlerName stri
 	req.NoReply = noReply
 
 	if noReply == false {
-		req.requestHandle = func(Returns interface{},Err error){
+		req.requestHandle = func(Returns interface{},Err *RpcError){
 			pCall.Err = Err
 			pCall.done <- pCall
 		}
@@ -244,7 +248,7 @@ func (slf *Server) rpcHandlerAsyncGo(callerRpcHandler IRpcHandler,noReply bool,m
 	req.MutiCoroutine = mutiCoroutine
 
 	if noReply == false {
-		req.requestHandle = func(Returns interface{},Err error){
+		req.requestHandle = func(Returns interface{},Err *RpcError){
 			pCall.Err = Err
 			if Returns!=nil {
 				pCall.Reply = Returns