Use class name as the default reference name

common/proxy/proxy.go

@@ -29,7 +29,6 @@ import (
 )
 
 import (
-	"dubbo.apache.org/dubbo-go/v3/common"
 	"dubbo.apache.org/dubbo-go/v3/common/constant"
 	"dubbo.apache.org/dubbo-go/v3/common/logger"
 	"dubbo.apache.org/dubbo-go/v3/protocol"
@@ -38,7 +37,7 @@ import (
 
 // nolint
 type Proxy struct {
-	rpc         common.RPCService
+	rpc         interface{}
 	invoke      protocol.Invoker
 	callback    interface{}
 	attachments map[string]string
@@ -50,7 +49,7 @@ type (
 	// ProxyOption a function to init Proxy with options
 	ProxyOption func(p *Proxy)
 	// ImplementFunc function for proxy impl of RPCService functions
-	ImplementFunc func(p *Proxy, v common.RPCService)
+	ImplementFunc func(p *Proxy, v interface{})
 )
 
 var typError = reflect.Zero(reflect.TypeOf((*error)(nil)).Elem()).Type()
@@ -87,15 +86,15 @@ func WithProxyImplementFunc(f ImplementFunc) ProxyOption {
 // 		type XxxProvider struct {
 //  		Yyy func(ctx context.Context, args []interface{}, rsp *Zzz) error
 // 		}
-func (p *Proxy) Implement(v common.RPCService) {
+func (p *Proxy) Implement(v interface{}) {
 	p.once.Do(func() {
 		p.implement(p, v)
 		p.rpc = v
 	})
 }
 
 // Get gets rpc service instance.
-func (p *Proxy) Get() common.RPCService {
+func (p *Proxy) Get() interface{} {
 	return p.rpc
 }
 
@@ -110,7 +109,7 @@ func (p *Proxy) GetInvoker() protocol.Invoker {
 }
 
 // DefaultProxyImplementFunc the default function for proxy impl
-func DefaultProxyImplementFunc(p *Proxy, v common.RPCService) {
+func DefaultProxyImplementFunc(p *Proxy, v interface{}) {
 	// check parameters, incoming interface must be a elem's pointer.
 	valueOf := reflect.ValueOf(v)
 	logger.Debugf("[Implement] reflect.TypeOf: %s", valueOf.String())

common/rpc_service.go

@@ -42,6 +42,32 @@ type RPCService interface {
 	Reference() string
 }
 
+// GetReference return the reference id of the service.
+// If the service implemented the RPCService interface,
+// it will call the Reference method. If not, it will
+// return the struct name as the reference id.
+func GetReference(service interface{}) string {
+	if s, ok := service.(RPCService); ok {
+		return s.Reference()
+	}
+
+	ref := ""
+	sType := reflect.TypeOf(service)
+	kind := sType.Kind()
+	switch kind {
+	case reflect.Struct:
+		ref = sType.Name()
+	case reflect.Ptr:
+		sName := sType.Elem().Name()
+		if sName != "" {
+			ref = sName
+		} else {
+			ref = sType.Elem().Field(0).Name
+		}
+	}
+	return ref
+}
+
 // AsyncCallbackService callback interface for async
 type AsyncCallbackService interface {
 	// Callback: callback
@@ -186,7 +212,7 @@ func (sm *serviceMap) GetInterface(interfaceName string) []*Service {
 }
 
 // Register registers a service by @interfaceName and @protocol
-func (sm *serviceMap) Register(interfaceName, protocol, group, version string, rcvr RPCService) (string, error) {
+func (sm *serviceMap) Register(interfaceName, protocol, group, version string, rcvr interface{}) (string, error) {
 	if sm.serviceMap[protocol] == nil {
 		sm.serviceMap[protocol] = make(map[string]*Service)
 	}

common/rpc_service_test.go

@@ -218,3 +218,36 @@ func TestSuiteMethod(t *testing.T) {
 	methodType = suiteMethod(method)
 	assert.Nil(t, methodType)
 }
+
+type ServiceWithoutRef struct{}
+
+func TestGetReference(t *testing.T) {
+	s0 := &TestService{}
+	ref0 := GetReference(s0)
+	assert.Equal(t, referenceTestPath, ref0)
+
+	//s1 := TestService{}
+	//ref1 := GetReference(s1)
+	//assert.Equal(t, referenceTestPath, ref1)
+
+	s2 := &struct {
+		TestService
+	}{}
+	ref2 := GetReference(s2)
+	assert.Equal(t, referenceTestPath, ref2)
+
+	expectedReference := "ServiceWithoutRef"
+	s3 := &ServiceWithoutRef{}
+	ref3 := GetReference(s3)
+	assert.Equal(t, expectedReference, ref3)
+
+	s4 := ServiceWithoutRef{}
+	ref4 := GetReference(s4)
+	assert.Equal(t, expectedReference, ref4)
+
+	s5 := &struct {
+		ServiceWithoutRef
+	}{}
+	ref5 := GetReference(s5)
+	assert.Equal(t, expectedReference, ref5)
+}

config/config_loader.go

@@ -395,13 +395,14 @@ func LoadWithOptions(options ...LoaderInitOption) {
 }
 
 // GetRPCService get rpc service for consumer
-func GetRPCService(name string) common.RPCService {
+func GetRPCService(name string) interface{} {
 	return consumerConfig.References[name].GetRPCService()
 }
 
 // RPCService create rpc service for consumer
-func RPCService(service common.RPCService) {
-	consumerConfig.References[service.Reference()].Implement(service)
+func RPCService(service interface{}) {
+	ref := common.GetReference(service)
+	consumerConfig.References[ref].Implement(service)
 }
 
 // GetMetricConfig find the MetricConfig

config/config_loader_test.go

@@ -114,8 +114,8 @@ func TestLoad(t *testing.T) {
 	RPCService(ms2)
 	assert.NotEqual(t, ms2, GetRPCService(ms2.Reference()))
 
-	conServices = map[string]common.RPCService{}
-	proServices = map[string]common.RPCService{}
+	conServices = map[string]interface{}{}
+	proServices = map[string]interface{}{}
 	err := common.ServiceMap.UnRegister("com.MockService", "mock",
 		common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
 	assert.Nil(t, err)
@@ -154,8 +154,8 @@ func TestLoadWithSingleReg(t *testing.T) {
 	RPCService(ms2)
 	assert.NotEqual(t, ms2, GetRPCService(ms2.Reference()))
 
-	conServices = map[string]common.RPCService{}
-	proServices = map[string]common.RPCService{}
+	conServices = map[string]interface{}{}
+	proServices = map[string]interface{}{}
 	common.ServiceMap.UnRegister("com.MockService", "mock", common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
 	consumerConfig = nil
 	providerConfig = nil
@@ -193,8 +193,8 @@ func TestWithNoRegLoad(t *testing.T) {
 	RPCService(ms2)
 	assert.NotEqual(t, ms2, GetRPCService(ms2.Reference()))
 
-	conServices = map[string]common.RPCService{}
-	proServices = map[string]common.RPCService{}
+	conServices = map[string]interface{}{}
+	proServices = map[string]interface{}{}
 	err := common.ServiceMap.UnRegister("com.MockService", "mock",
 		common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
 	assert.Nil(t, err)

config/reference_config.go

@@ -209,12 +209,12 @@ func (c *ReferenceConfig) Refer(_ interface{}) {
 
 // Implement
 // @v is service provider implemented RPCService
-func (c *ReferenceConfig) Implement(v common.RPCService) {
+func (c *ReferenceConfig) Implement(v interface{}) {
 	c.pxy.Implement(v)
 }
 
 // GetRPCService gets RPCService from proxy
-func (c *ReferenceConfig) GetRPCService() common.RPCService {
+func (c *ReferenceConfig) GetRPCService() interface{} {
 	return c.pxy.Get()
 }
 

config/service.go

@@ -22,32 +22,34 @@ import (
 )
 
 var (
-	conServices = map[string]common.RPCService{} // service name -> service
-	proServices = map[string]common.RPCService{} // service name -> service
+	conServices = map[string]interface{}{} // service name -> service
+	proServices = map[string]interface{}{} // service name -> service
 )
 
 // SetConsumerService is called by init() of implement of RPCService
-func SetConsumerService(service common.RPCService) {
-	conServices[service.Reference()] = service
+func SetConsumerService(service interface{}) {
+	ref := common.GetReference(service)
+	conServices[ref] = service
 }
 
 // SetProviderService is called by init() of implement of RPCService
-func SetProviderService(service common.RPCService) {
-	proServices[service.Reference()] = service
+func SetProviderService(service interface{}) {
+	ref := common.GetReference(service)
+	proServices[ref] = service
 }
 
 // GetConsumerService gets ConsumerService by @name
-func GetConsumerService(name string) common.RPCService {
+func GetConsumerService(name string) interface{} {
 	return conServices[name]
 }
 
 // GetProviderService gets ProviderService by @name
-func GetProviderService(name string) common.RPCService {
+func GetProviderService(name string) interface{} {
 	return proServices[name]
 }
 
 // GetAllProviderService gets all ProviderService
-func GetAllProviderService() map[string]common.RPCService {
+func GetAllProviderService() map[string]interface{} {
 	return proServices
 }
 

config/service_config.go

@@ -77,7 +77,7 @@ type ServiceConfig struct {
 	unexported    *atomic.Bool
 	exported      *atomic.Bool
 	export        bool // a flag to control whether the current service should export or not
-	rpcService    common.RPCService
+	rpcService    interface{}
 	cacheMutex    sync.Mutex
 	cacheProtocol protocol.Protocol
 
@@ -267,7 +267,7 @@ func (c *ServiceConfig) Unexport() {
 }
 
 // Implement only store the @s and return
-func (c *ServiceConfig) Implement(s common.RPCService) {
+func (c *ServiceConfig) Implement(s interface{}) {
 	c.rpcService = s
 }
 

metadata/service/local_service.go

@@ -94,7 +94,7 @@ func (mts *BaseMetadataService) ServiceName() (string, error) {
 	return mts.serviceName, nil
 }
 
-// Version will return the version of metadata service
+// Reference will return the reference id of metadata service
 func (mts *BaseMetadataService) Reference() string {
 	return constant.SIMPLE_METADATA_SERVICE_NAME
 }