feat(triple): support generic call for Triple protocol

- Add protoWrapperCodec for client-side generic call serialization
- Add WrapperCodec interface for wrapper-based codecs
- Enhance protoBinaryCodec to handle TripleRequestWrapper/TripleResponseWrapper
- Add WithGeneric() client option to enable generic call mode
- Auto-register $invoke method on server side for generic call handling
- Add reflection-based method invocation in server
- Enhance Go-to-Java type mapping in generic filter
- Support hessian2 serialization for cross-language interoperability

This enables dubbo-go to make generic calls to Java Dubbo services
using Triple protocol without pre-generated stubs.

Tested with:
- Go client -> Java server: PASS
- Java client -> Go server: PASS
- Go client -> Go server: PASS

Signed-off-by: TsukiKage <[email protected]>

Author: Tsukikage7

client/options.go

@@ -382,6 +382,14 @@ func WithGeneric() ReferenceOption {
 	}
 }
 
+// WithGenericType sets the generic serialization type for generic call
+// Valid values: "true" (default), "gson", "protobuf"
+func WithGenericType(genericType string) ReferenceOption {
+	return func(opts *ReferenceOptions) {
+		opts.Reference.Generic = genericType
+	}
+}
+
 func WithSticky() ReferenceOption {
 	return func(opts *ReferenceOptions) {
 		opts.Reference.Sticky = true

common/constant/key.go

@@ -413,8 +413,10 @@ const (
 
 // Generic Filter
 const (
-	GenericSerializationDefault = "true"
-	GenericSerializationGson    = "gson"
+	GenericSerializationDefault      = "true"
+	GenericSerializationGson         = "gson"
+	GenericSerializationProtobuf     = "protobuf"
+	GenericSerializationProtobufJson = "protobuf-json"
 )
 
 // AdaptiveService Filter

filter/generic/filter.go

@@ -95,10 +95,31 @@ func (f *genericFilter) Invoke(ctx context.Context, invoker base.Invoker, inv ba
 			types,
 			args,
 		}
-		newIvc := invocation.NewRPCInvocation(constant.Generic, newArgs, inv.Attachments())
-		newIvc.SetReply(inv.Reply())
+
+		// For Triple protocol non-IDL mode, we need to set parameterRawValues
+		// The format is [param1, param2, ..., paramN, reply] where the last element is the reply placeholder
+		// Triple invoker slices as: request = inRaw[0:len-1], reply = inRaw[len-1]
+		// So for generic call, we need [methodName, types, args, reply] to get request = [methodName, types, args]
+		reply := inv.Reply()
+		parameterRawValues := []any{mtdName, types, args, reply}
+
+		newIvc := invocation.NewRPCInvocationWithOptions(
+			invocation.WithMethodName(constant.Generic),
+			invocation.WithArguments(newArgs),
+			invocation.WithParameterRawValues(parameterRawValues),
+			invocation.WithAttachments(inv.Attachments()),
+			invocation.WithReply(reply),
+		)
 		newIvc.Attachments()[constant.GenericKey] = invoker.GetURL().GetParam(constant.GenericKey, "")
 
+		// Copy CallType attribute from original invocation for Triple protocol support
+		// If not present, set default to CallUnary for generic calls
+		if callType, ok := inv.GetAttribute(constant.CallTypeKey); ok {
+			newIvc.SetAttribute(constant.CallTypeKey, callType)
+		} else {
+			newIvc.SetAttribute(constant.CallTypeKey, constant.CallUnary)
+		}
+
 		return invoker.Invoke(ctx, newIvc)
 	} else if isMakingAGenericCall(invoker, inv) {
 		inv.Attachments()[constant.GenericKey] = invoker.GetURL().GetParam(constant.GenericKey, "")

protocol/triple/client.go

@@ -284,7 +284,18 @@ func newClientManager(url *common.URL) (*clientManager, error) {
 
 	triClients := make(map[string]*tri.Client)
 
-	if len(url.Methods) != 0 {
+	// Check if this is a generic call - for generic call, we only need $invoke method
+	generic := url.GetParam(constant.GenericKey, "")
+	isGeneric := isGenericCall(generic)
+
+	if isGeneric {
+		// For generic call, only register $invoke method
+		invokeURL, err := joinPath(baseTriURL, url.Interface(), constant.Generic)
+		if err != nil {
+			return nil, fmt.Errorf("JoinPath failed for base %s, interface %s, method %s", baseTriURL, url.Interface(), constant.Generic)
+		}
+		triClients[constant.Generic] = tri.NewClient(httpClient, invokeURL, cliOpts...)
+	} else if len(url.Methods) != 0 {
 		for _, method := range url.Methods {
 			triURL, err := joinPath(baseTriURL, url.Interface(), method)
 			if err != nil {
@@ -312,6 +323,13 @@ func newClientManager(url *common.URL) (*clientManager, error) {
 			triClient := tri.NewClient(httpClient, triURL, cliOpts...)
 			triClients[methodName] = triClient
 		}
+
+		// Register $invoke method for generic call support in non-IDL mode
+		invokeURL, err := joinPath(baseTriURL, url.Interface(), constant.Generic)
+		if err != nil {
+			return nil, fmt.Errorf("JoinPath failed for base %s, interface %s, method %s", baseTriURL, url.Interface(), constant.Generic)
+		}
+		triClients[constant.Generic] = tri.NewClient(httpClient, invokeURL, cliOpts...)
 	}
 
 	return &clientManager{

protocol/triple/server.go

@@ -503,51 +503,85 @@ func createServiceInfoWithReflection(svc common.RPCService) *common.ServiceInfo
 		if methodType.Name == "Reference" {
 			continue
 		}
-		paramsNum := methodType.Type.NumIn()
-		// the first param is receiver itself, the second param is ctx
-		// just ignore them
-		if paramsNum < 2 {
-			logger.Fatalf("TRIPLE does not support %s method that does not have any parameter", methodType.Name)
-			continue
-		}
-		paramsTypes := make([]reflect.Type, paramsNum-2)
-		for j := 2; j < paramsNum; j++ {
-			paramsTypes[j-2] = methodType.Type.In(j)
-		}
-		methodInfo := common.MethodInfo{
-			Name: methodType.Name,
-			// only support Unary invocation now
-			Type: constant.CallUnary,
-			ReqInitFunc: func() any {
-				params := make([]any, len(paramsTypes))
-				for k, paramType := range paramsTypes {
-					params[k] = reflect.New(paramType).Interface()
-				}
-				return params
-			},
+		methodInfo := buildMethodInfoWithReflection(methodType)
+		if methodInfo != nil {
+			methodInfos = append(methodInfos, *methodInfo)
 		}
-		methodInfos = append(methodInfos, methodInfo)
 	}
 
-	// only support no-idl mod call unary
-	genericMethodInfo := common.MethodInfo{
-		Name: "$invoke",
-		Type: constant.CallUnary,
+	// Add $invoke method for generic call support
+	methodInfos = append(methodInfos, buildGenericMethodInfo())
+
+	info.Methods = methodInfos
+	return &info
+}
+
+// buildMethodInfoWithReflection creates MethodInfo for a single method using reflection.
+func buildMethodInfoWithReflection(methodType reflect.Method) *common.MethodInfo {
+	paramsNum := methodType.Type.NumIn()
+	// the first param is receiver itself, the second param is ctx
+	if paramsNum < 2 {
+		logger.Fatalf("TRIPLE does not support %s method that does not have any parameter", methodType.Name)
+		return nil
+	}
+
+	// Extract parameter types (skip receiver and context)
+	paramsTypes := make([]reflect.Type, paramsNum-2)
+	for j := 2; j < paramsNum; j++ {
+		paramsTypes[j-2] = methodType.Type.In(j)
+	}
+
+	// Capture method for closure
+	method := methodType
+	return &common.MethodInfo{
+		Name: methodType.Name,
+		Type: constant.CallUnary, // only support Unary invocation now
 		ReqInitFunc: func() any {
-			params := make([]any, 3)
-			// params must be pointer
-			params[0] = func(s string) *string { return &s }("methodName") // methodName *string
-			params[1] = &[]string{}                                        // argv type  *[]string
-			params[2] = &[]hessian.Object{}                                // argv       *[]hessian.Object
+			params := make([]any, len(paramsTypes))
+			for k, paramType := range paramsTypes {
+				params[k] = reflect.New(paramType).Interface()
+			}
 			return params
 		},
+		MethodFunc: func(ctx context.Context, args []any, handler any) (any, error) {
+			in := []reflect.Value{reflect.ValueOf(handler)}
+			in = append(in, reflect.ValueOf(ctx))
+			for _, arg := range args {
+				in = append(in, reflect.ValueOf(arg))
+			}
+			returnValues := method.Func.Call(in)
+			if len(returnValues) == 1 {
+				if returnValues[0].IsNil() {
+					return nil, nil
+				}
+				return nil, returnValues[0].Interface().(error)
+			}
+			var result any
+			var err error
+			if !returnValues[0].IsNil() {
+				result = returnValues[0].Interface()
+			}
+			if len(returnValues) > 1 && !returnValues[1].IsNil() {
+				err = returnValues[1].Interface().(error)
+			}
+			return result, err
+		},
 	}
+}
 
-	methodInfos = append(methodInfos, genericMethodInfo)
-
-	info.Methods = methodInfos
-
-	return &info
+// buildGenericMethodInfo creates MethodInfo for $invoke generic call method.
+func buildGenericMethodInfo() common.MethodInfo {
+	return common.MethodInfo{
+		Name: constant.Generic,
+		Type: constant.CallUnary,
+		ReqInitFunc: func() any {
+			return []any{
+				func(s string) *string { return &s }(""), // methodName *string
+				&[]string{},                              // types *[]string
+				&[]hessian.Object{},                      // args *[]hessian.Object
+			}
+		},
+	}
 }
 
 // generateAttachments transfer http.Header to map[string]any and make all keys lowercase

protocol/triple/triple.go

@@ -19,6 +19,7 @@ package triple
 
 import (
 	"context"
+	"strings"
 	"sync"
 )
 
@@ -110,9 +111,16 @@ func (tp *TripleProtocol) Refer(url *common.URL) base.Invoker {
 	IDLMode := url.GetParam(constant.IDLMode, "")
 	// for now, we do not need to use this info
 	_, ok := url.GetAttribute(constant.ClientInfoKey)
-	// isIDL is NONIDL means new triple non-IDL mode
-	if ok || IDLMode == constant.NONIDL {
-		// stub code generated by new protoc-gen-go-triple
+	// Check if this is a generic call
+	generic := url.GetParam(constant.GenericKey, "")
+	isGenericCall := isGenericCall(generic)
+
+	// Use NewTripleInvoker for:
+	// 1. New protoc-gen-go-triple stub code (has ClientInfoKey)
+	// 2. Non-IDL mode (IDLMode == NONIDL)
+	// 3. Generic call (generic=true/gson/protobuf/protobuf-json)
+	if ok || IDLMode == constant.NONIDL || isGenericCall {
+		// new triple invoker supporting $invoke for generic calls
 		invoker, err = NewTripleInvoker(url)
 	} else {
 		// stub code generated by old protoc-gen-go-triple
@@ -141,6 +149,18 @@ func (tp *TripleProtocol) Destroy() {
 	tp.BaseProtocol.Destroy()
 }
 
+// isGenericCall checks if the generic parameter indicates a generic call
+func isGenericCall(generic string) bool {
+	if generic == "" {
+		return false
+	}
+	lowerGeneric := strings.ToLower(generic)
+	return lowerGeneric == constant.GenericSerializationDefault ||
+		lowerGeneric == constant.GenericSerializationGson ||
+		lowerGeneric == constant.GenericSerializationProtobuf ||
+		lowerGeneric == constant.GenericSerializationProtobufJson
+}
+
 func NewTripleProtocol() *TripleProtocol {
 	return &TripleProtocol{
 		BaseProtocol: base.NewBaseProtocol(),