fix(triple): move SwapCase alias registration to transport layer (apache#3162)

Problem:
Triple protocol routes requests by URL path (/{interface}/{method}).
Go providers export PascalCase names (GetUser) while Java clients send
camelCase paths (getUser), causing 404 for alias-path calls.

The previous workaround (PR apache#3154) appended swapped-case MethodInfo
entries to ServiceInfo.Methods, polluting registry metadata and gRPC
reflection with duplicate method names (GetUser + getUser).

Solution:
- enhanceServiceInfo: remove SwapCase alias appending; only fill in
  missing MethodFunc via reflection. ServiceInfo.Methods stays clean.
- handleServiceWithInfo: extract registerMethodHandler; register each
  method under both the canonical path and the first-rune-swapped path.
  The alias path reuses the original MethodInfo unchanged so that:
  1. infoProxyInvoker can look up the method by its canonical name
     (proxy/proxy_factory/default.go uses ServiceInfo.Methods for the
     lookup table).
  2. Method-scoped provider config (methods.<Name>.*) continues to
     apply; config is keyed by the canonical Go/proto name in
     server/action.go, and filters read via invocation.MethodName().
- Restore swapped-case index in enhanceServiceInfo methodMap so that
  ServiceInfo entries using Java-style lowercase names (e.g. "ping")
  can still find the exported Go method ("Ping") for MethodFunc backfill.

Compatibility:
- ServiceInfo.Methods: only original canonical names (clean metadata)
- Registry / gRPC reflection: no duplicate entries
- infoProxyInvoker: unaffected, lookups still use canonical names
- Method-scoped config keys: unchanged, use canonical name (e.g. SayHello)
- Java alias paths: routed correctly without changing invocation semantics

Alias path note:
methods.<MethodName>.* config keys use the canonical Go/proto name.
Java-style aliases (sayHello) are routing-only and are not valid
provider method-scoped config keys.

Signed-off-by: MoChengqian <mochengqian@example.com>

Author: mochengqian

protocol/triple/server.go

@@ -42,6 +42,7 @@ import (
 import (
 	"dubbo.apache.org/dubbo-go/v3/common"
 	"dubbo.apache.org/dubbo-go/v3/common/constant"
+	"dubbo.apache.org/dubbo-go/v3/common/dubboutil"
 	"dubbo.apache.org/dubbo-go/v3/global"
 	"dubbo.apache.org/dubbo-go/v3/internal"
 	"dubbo.apache.org/dubbo-go/v3/protocol/base"
@@ -320,109 +321,133 @@ func (s *Server) compatRegisterHandler(interfaceName string, svc dubbo3.Dubbo3Gr
 	}
 }
 
-// handleServiceWithInfo injects invoker and create handler based on ServiceInfo
+// handleServiceWithInfo injects invoker and creates handlers based on ServiceInfo.
+// Each method is registered under both its original procedure path and the
+// first-rune-swapped path, so Java clients (camelCase) and Go clients
+// (PascalCase) can both reach the same handler without polluting ServiceInfo.
 func (s *Server) handleServiceWithInfo(interfaceName string, invoker base.Invoker, info *common.ServiceInfo, opts ...tri.HandlerOption) {
 	for _, method := range info.Methods {
 		m := method
 		procedure := joinProcedure(interfaceName, method.Name)
-		switch m.Type {
-		case constant.CallUnary:
-			_ = s.triServer.RegisterUnaryHandler(
-				procedure,
-				m.ReqInitFunc,
-				func(ctx context.Context, req *tri.Request) (*tri.Response, error) {
-					var args []any
-					if argsRaw, ok := req.Msg.([]any); ok {
-						// non-idl mode, req.Msg consists of many arguments
-						for _, argRaw := range argsRaw {
-							// refer to createServiceInfoWithReflection, in ReqInitFunc, argRaw is a pointer to real arg.
-							// so we have to invoke Elem to get the real arg.
-							args = append(args, reflect.ValueOf(argRaw).Elem().Interface())
-						}
-					} else {
-						// triple idl mode and old triple idl mode
-						args = append(args, req.Msg)
-					}
-					attachments := generateAttachments(req.Header())
-					// inject attachments
-					ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
-					invo := invocation.NewRPCInvocation(m.Name, args, attachments)
-					res := invoker.Invoke(ctx, invo)
-					// todo(DMwangnima): modify InfoInvoker to get a unified processing logic
-					// please refer to server/InfoInvoker.Invoke()
-					var triResp *tri.Response
-					if existingResp, ok := res.Result().(*tri.Response); ok {
-						triResp = existingResp
-					} else {
-						// please refer to proxy/proxy_factory/ProxyInvoker.Invoke
-						triResp = tri.NewResponse([]any{res.Result()})
+		s.registerMethodHandler(procedure, m, invoker, opts...)
+
+		// Also register the first-rune-swapped procedure so that Java clients
+		// sending camelCase method names (e.g. getUser) reach Go handlers
+		// registered as PascalCase (e.g. GetUser), and vice-versa.
+		//
+		// The original m (with the Go/proto name) is passed unchanged so that:
+		//   1. infoProxyInvoker can look up the method by its canonical name.
+		//   2. Method-scoped provider config ("methods.SayHello.*") continues
+		//      to apply; filters look up via invocation.MethodName(), which
+		//      must match the key written by server/action.go.
+		//
+		// Only the HTTP procedure path varies between the two registrations;
+		// the invocation name and MethodInfo are shared.
+		if swappedName := dubboutil.SwapCaseFirstRune(method.Name); joinProcedure(interfaceName, swappedName) != procedure {
+			s.registerMethodHandler(joinProcedure(interfaceName, swappedName), m, invoker, opts...)
+		}
+	}
+}
+
+// registerMethodHandler registers a single method handler for the given procedure path.
+func (s *Server) registerMethodHandler(procedure string, m common.MethodInfo, invoker base.Invoker, opts ...tri.HandlerOption) {
+	switch m.Type {
+	case constant.CallUnary:
+		_ = s.triServer.RegisterUnaryHandler(
+			procedure,
+			m.ReqInitFunc,
+			func(ctx context.Context, req *tri.Request) (*tri.Response, error) {
+				var args []any
+				if argsRaw, ok := req.Msg.([]any); ok {
+					// non-idl mode, req.Msg consists of many arguments
+					for _, argRaw := range argsRaw {
+						// refer to createServiceInfoWithReflection, in ReqInitFunc, argRaw is a pointer to real arg.
+						// so we have to invoke Elem to get the real arg.
+						args = append(args, reflect.ValueOf(argRaw).Elem().Interface())
 					}
-					for k, v := range res.Attachments() {
-						switch val := v.(type) {
-						case string:
-							tri.AppendToOutgoingContext(ctx, k, val)
-						case []string:
-							for _, v := range val {
-								tri.AppendToOutgoingContext(ctx, k, v)
-							}
+				} else {
+					// triple idl mode and old triple idl mode
+					args = append(args, req.Msg)
+				}
+				attachments := generateAttachments(req.Header())
+				// inject attachments
+				ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
+				invo := invocation.NewRPCInvocation(m.Name, args, attachments)
+				res := invoker.Invoke(ctx, invo)
+				// todo(DMwangnima): modify InfoInvoker to get a unified processing logic
+				// please refer to server/InfoInvoker.Invoke()
+				var triResp *tri.Response
+				if existingResp, ok := res.Result().(*tri.Response); ok {
+					triResp = existingResp
+				} else {
+					// please refer to proxy/proxy_factory/ProxyInvoker.Invoke
+					triResp = tri.NewResponse([]any{res.Result()})
+				}
+				for k, v := range res.Attachments() {
+					switch val := v.(type) {
+					case string:
+						tri.AppendToOutgoingContext(ctx, k, val)
+					case []string:
+						for _, v := range val {
+							tri.AppendToOutgoingContext(ctx, k, v)
 						}
 					}
+				}
+				return triResp, res.Error()
+			},
+			opts...,
+		)
+	case constant.CallClientStream:
+		_ = s.triServer.RegisterClientStreamHandler(
+			procedure,
+			func(ctx context.Context, stream *tri.ClientStream) (*tri.Response, error) {
+				var args []any
+				args = append(args, m.StreamInitFunc(stream))
+				attachments := generateAttachments(stream.RequestHeader())
+				// inject attachments
+				ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
+				invo := invocation.NewRPCInvocation(m.Name, args, attachments)
+				res := invoker.Invoke(ctx, invo)
+				if triResp, ok := res.Result().(*tri.Response); ok {
 					return triResp, res.Error()
-				},
-				opts...,
-			)
-		case constant.CallClientStream:
-			_ = s.triServer.RegisterClientStreamHandler(
-				procedure,
-				func(ctx context.Context, stream *tri.ClientStream) (*tri.Response, error) {
-					var args []any
-					args = append(args, m.StreamInitFunc(stream))
-					attachments := generateAttachments(stream.RequestHeader())
-					// inject attachments
-					ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
-					invo := invocation.NewRPCInvocation(m.Name, args, attachments)
-					res := invoker.Invoke(ctx, invo)
-					if triResp, ok := res.Result().(*tri.Response); ok {
-						return triResp, res.Error()
-					}
-					// please refer to proxy/proxy_factory/ProxyInvoker.Invoke
-					triResp := tri.NewResponse([]any{res.Result()})
-					return triResp, res.Error()
-				},
-				opts...,
-			)
-		case constant.CallServerStream:
-			_ = s.triServer.RegisterServerStreamHandler(
-				procedure,
-				m.ReqInitFunc,
-				func(ctx context.Context, req *tri.Request, stream *tri.ServerStream) error {
-					var args []any
-					args = append(args, req.Msg, m.StreamInitFunc(stream))
-					attachments := generateAttachments(req.Header())
-					// inject attachments
-					ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
-					invo := invocation.NewRPCInvocation(m.Name, args, attachments)
-					res := invoker.Invoke(ctx, invo)
-					return res.Error()
-				},
-				opts...,
-			)
-		case constant.CallBidiStream:
-			_ = s.triServer.RegisterBidiStreamHandler(
-				procedure,
-				func(ctx context.Context, stream *tri.BidiStream) error {
-					var args []any
-					args = append(args, m.StreamInitFunc(stream))
-					attachments := generateAttachments(stream.RequestHeader())
-					// inject attachments
-					ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
-					invo := invocation.NewRPCInvocation(m.Name, args, attachments)
-					res := invoker.Invoke(ctx, invo)
-					return res.Error()
-				},
-				opts...,
-			)
-		}
+				}
+				// please refer to proxy/proxy_factory/ProxyInvoker.Invoke
+				triResp := tri.NewResponse([]any{res.Result()})
+				return triResp, res.Error()
+			},
+			opts...,
+		)
+	case constant.CallServerStream:
+		_ = s.triServer.RegisterServerStreamHandler(
+			procedure,
+			m.ReqInitFunc,
+			func(ctx context.Context, req *tri.Request, stream *tri.ServerStream) error {
+				var args []any
+				args = append(args, req.Msg, m.StreamInitFunc(stream))
+				attachments := generateAttachments(req.Header())
+				// inject attachments
+				ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
+				invo := invocation.NewRPCInvocation(m.Name, args, attachments)
+				res := invoker.Invoke(ctx, invo)
+				return res.Error()
+			},
+			opts...,
+		)
+	case constant.CallBidiStream:
+		_ = s.triServer.RegisterBidiStreamHandler(
+			procedure,
+			func(ctx context.Context, stream *tri.BidiStream) error {
+				var args []any
+				args = append(args, m.StreamInitFunc(stream))
+				attachments := generateAttachments(stream.RequestHeader())
+				// inject attachments
+				ctx = context.WithValue(ctx, constant.AttachmentKey, attachments)
+				invo := invocation.NewRPCInvocation(m.Name, args, attachments)
+				res := invoker.Invoke(ctx, invo)
+				return res.Error()
+			},
+			opts...,
+		)
 	}
 }
 

protocol/triple/server_test.go

@@ -36,6 +36,7 @@ import (
 import (
 	"dubbo.apache.org/dubbo-go/v3/common"
 	"dubbo.apache.org/dubbo-go/v3/common/constant"
+	"dubbo.apache.org/dubbo-go/v3/common/dubboutil"
 	"dubbo.apache.org/dubbo-go/v3/global"
 )
 
@@ -542,3 +543,128 @@ func Test_isReflectValueNil_UnsafePointer(t *testing.T) {
 		assert.False(t, isReflectValueNil(v))
 	})
 }
+
+// TestHandleServiceWithInfo_DualProcedure verifies that handleServiceWithInfo
+// produces two distinct procedure paths for each method (original + swapped
+// first-rune case), enabling Go/Java cross-language interoperability without
+// polluting ServiceInfo.Methods.
+func TestHandleServiceWithInfo_DualProcedure(t *testing.T) {
+	const interfaceName = "com.example.GreetService"
+
+	tests := []struct {
+		methodName    string
+		wantOriginal  string
+		wantSwapped   string
+		distinctPaths bool
+	}{
+		{
+			// Go PascalCase: Java sends "greet", Go registers "Greet"
+			methodName:    "Greet",
+			wantOriginal:  "/" + interfaceName + "/Greet",
+			wantSwapped:   "/" + interfaceName + "/greet",
+			distinctPaths: true,
+		},
+		{
+			// Java camelCase coming in: Go handler is "GetUser"
+			methodName:    "getUser",
+			wantOriginal:  "/" + interfaceName + "/getUser",
+			wantSwapped:   "/" + interfaceName + "/GetUser",
+			distinctPaths: true,
+		},
+		{
+			// Edge case: single lowercase rune
+			methodName:    "a",
+			wantOriginal:  "/" + interfaceName + "/a",
+			wantSwapped:   "/" + interfaceName + "/A",
+			distinctPaths: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.methodName, func(t *testing.T) {
+			original := joinProcedure(interfaceName, tt.methodName)
+			swapped := joinProcedure(interfaceName, dubboutil.SwapCaseFirstRune(tt.methodName))
+
+			assert.Equal(t, tt.wantOriginal, original)
+			assert.Equal(t, tt.wantSwapped, swapped)
+			if tt.distinctPaths {
+				assert.NotEqual(t, original, swapped,
+					"original and swapped procedures must be distinct so both get registered")
+			}
+		})
+	}
+}
+
+// TestHandleServiceWithInfo_AliasSharesMethodInfo verifies the contract of
+// handleServiceWithInfo's alias registration:
+//
+//   - The alias path (e.g. /.../sayHello) and the original path (/.../SayHello)
+//     share the same MethodInfo — including the same m.Name (Go/proto name).
+//   - Only the HTTP procedure path differs; the invocation name is unchanged.
+//
+// This is required for two reasons:
+//  1. infoProxyInvoker builds its lookup table from ServiceInfo.Methods[i].Name
+//     (proxy/proxy_factory/default.go:194-198).  If the invocation carries the
+//     alias name ("sayHello"), the lookup fails with "no match method for …".
+//  2. Method-scoped provider config is keyed as "methods."+v.Name+"." in
+//     server/action.go:412.  Filters look up via invocation.MethodName(), so
+//     the invocation must carry the Go name for config to apply correctly.
+func TestHandleServiceWithInfo_AliasSharesMethodInfo(t *testing.T) {
+	const interfaceName = "com.example.GreetService"
+
+	cases := []struct {
+		goName    string // canonical name in ServiceInfo.Methods and config keys
+		aliasName string // first-rune-swapped name used only as URL path
+	}{
+		{"SayHello", "sayHello"},
+		{"GetUser", "getUser"},
+		{"greet", "Greet"},
+	}
+
+	for _, c := range cases {
+		t.Run(c.goName, func(t *testing.T) {
+			m := common.MethodInfo{Name: c.goName, Type: constant.CallUnary}
+
+			// Simulate what handleServiceWithInfo does for the alias path:
+			// only the procedure path changes; m is passed unchanged.
+			originalProcedure := joinProcedure(interfaceName, m.Name)
+			aliasProcedure := joinProcedure(interfaceName, dubboutil.SwapCaseFirstRune(m.Name))
+
+			assert.NotEqual(t, originalProcedure, aliasProcedure,
+				"alias procedure path must differ from the original")
+			assert.Equal(t, c.goName, m.Name,
+				"MethodInfo.Name must remain the Go/proto name so infoProxyInvoker and config lookups succeed")
+			assert.Equal(t, c.aliasName, dubboutil.SwapCaseFirstRune(m.Name),
+				"SwapCaseFirstRune produces the alias URL segment, not the invocation name")
+		})
+	}
+}
+
+// TestHandleServiceWithInfo_SaveServiceInfo_OnlyOriginalMethods verifies that
+// saveServiceInfo (called after handleServiceWithInfo) only records the original
+// method names – not swapped-case aliases – so registry/gRPC-reflection
+// metadata stays clean.
+func TestHandleServiceWithInfo_SaveServiceInfo_OnlyOriginalMethods(t *testing.T) {
+	server := NewServer(nil)
+	info := &common.ServiceInfo{
+		Methods: []common.MethodInfo{
+			{Name: "GetUser", Type: constant.CallUnary},
+			{Name: "ListUsers", Type: constant.CallServerStream},
+		},
+	}
+	server.saveServiceInfo("com.example.UserService", info)
+
+	svcInfo := server.GetServiceInfo()
+	svc, ok := svcInfo["com.example.UserService"]
+	assert.True(t, ok)
+	// Only the two original methods; no "getUser" / "listUsers" aliases.
+	assert.Len(t, svc.Methods, 2)
+	names := make([]string, 0, len(svc.Methods))
+	for _, m := range svc.Methods {
+		names = append(names, m.Name)
+	}
+	assert.Contains(t, names, "GetUser")
+	assert.Contains(t, names, "ListUsers")
+	assert.NotContains(t, names, "getUser")
+	assert.NotContains(t, names, "listUsers")
+}