Merge pull request #194 from hxmhlt/config_center

Add: new feature to support dynamic config center which compatible with dubbo 2.6.x & 2.7.x

.gitignore

@@ -29,4 +29,4 @@ coverage.txt
 # unit test
 remoting/zookeeper/zookeeper-4unittest/
 config_center/zookeeper/zookeeper-4unittest/
-registry/zookeeper/zookeeper-4unittest/
\ No newline at end of file
+registry/zookeeper/zookeeper-4unittest/

before_ut.sh

+mkdir -p remoting/zookeeper/zookeeper-4unittest/contrib/fatjar config_center/zookeeper/zookeeper-4unittest/contrib/fatjar registry/zookeeper/zookeeper-4unittest/contrib/fatjar
+wget -P "remoting/zookeeper/zookeeper-4unittest/contrib/fatjar" https://github.com/dubbogo/resources/raw/master/zookeeper-4unitest/contrib/fatjar/zookeeper-3.4.9-fatjar.jar
+cp remoting/zookeeper/zookeeper-4unittest/contrib/fatjar/zookeeper-3.4.9-fatjar.jar config_center/zookeeper/zookeeper-4unittest/contrib/fatjar/
+cp remoting/zookeeper/zookeeper-4unittest/contrib/fatjar/zookeeper-3.4.9-fatjar.jar registry/zookeeper/zookeeper-4unittest/contrib/fatjar/
\ No newline at end of file

cluster/directory/base_directory.go

@@ -42,6 +42,9 @@ func NewBaseDirectory(url *common.URL) BaseDirectory {
 func (dir *BaseDirectory) GetUrl() common.URL {
 	return *dir.url
 }
+func (dir *BaseDirectory) GetDirectoryUrl() *common.URL {
+	return dir.url
+}
 
 func (dir *BaseDirectory) Destroy(doDestroy func()) {
 	if dir.destroyed.CAS(false, true) {

common/config/environment.go

@@ -23,15 +23,21 @@ import (
 	"sync"
 )
 
+import (
+	"github.com/apache/dubbo-go/config_center"
+)
+
 // There is dubbo.properties file and application level config center configuration which higner than normal config center in java. So in java the
 // configuration sequence will be config center > application level config center > dubbo.properties > spring bean configuration.
 // But in go, neither the dubbo.properties file or application level config center configuration will not support for the time being.
 // We just have config center configuration which can override configuration in consumer.yaml & provider.yaml.
 // But for add these features in future ,I finish the environment struct following Environment class in java.
 type Environment struct {
-	configCenterFirst bool
-	externalConfigs   sync.Map
-	externalConfigMap sync.Map
+	configCenterFirst    bool
+	externalConfigs      sync.Map
+	externalConfigMap    sync.Map
+	appExternalConfigMap sync.Map
+	dynamicConfiguration config_center.DynamicConfiguration
 }
 
 var (
@@ -45,6 +51,9 @@ func GetEnvInstance() *Environment {
 	})
 	return instance
 }
+func NewEnvInstance() {
+	instance = &Environment{configCenterFirst: true}
+}
 
 //func (env *Environment) SetConfigCenterFirst() {
 //	env.configCenterFirst = true
@@ -60,23 +69,34 @@ func (env *Environment) UpdateExternalConfigMap(externalMap map[string]string) {
 	}
 }
 
+func (env *Environment) UpdateAppExternalConfigMap(externalMap map[string]string) {
+	for k, v := range externalMap {
+		env.appExternalConfigMap.Store(k, v)
+	}
+}
+
 func (env *Environment) Configuration() *list.List {
 	list := list.New()
-	memConf := newInmemoryConfiguration()
-	memConf.setProperties(&(env.externalConfigMap))
-	list.PushBack(memConf)
+	// The sequence would be: SystemConfiguration -> ExternalConfiguration -> AppExternalConfiguration -> AbstractConfig -> PropertiesConfiguration
+	list.PushFront(newInmemoryConfiguration(&(env.externalConfigMap)))
+	list.PushFront(newInmemoryConfiguration(&(env.appExternalConfigMap)))
 	return list
 }
 
+func (env *Environment) SetDynamicConfiguration(dc config_center.DynamicConfiguration) {
+	env.dynamicConfiguration = dc
+}
+
+func (env *Environment) GetDynamicConfiguration() config_center.DynamicConfiguration {
+	return env.dynamicConfiguration
+}
+
 type InmemoryConfiguration struct {
 	store *sync.Map
 }
 
-func newInmemoryConfiguration() *InmemoryConfiguration {
-	return &InmemoryConfiguration{}
-}
-func (conf *InmemoryConfiguration) setProperties(p *sync.Map) {
-	conf.store = p
+func newInmemoryConfiguration(p *sync.Map) *InmemoryConfiguration {
+	return &InmemoryConfiguration{store: p}
 }
 
 func (conf *InmemoryConfiguration) GetProperty(key string) (bool, string) {

common/config/environment_test.go

@@ -19,6 +19,7 @@ package config
 import (
 	"testing"
 )
+
 import (
 	"github.com/stretchr/testify/assert"
 )
@@ -38,7 +39,7 @@ func TestEnvironment_UpdateExternalConfigMap(t *testing.T) {
 func TestEnvironment_ConfigurationAndGetProperty(t *testing.T) {
 	GetEnvInstance().UpdateExternalConfigMap(map[string]string{"1": "2"})
 	list := GetEnvInstance().Configuration()
-	ok, v := list.Front().Value.(*InmemoryConfiguration).GetProperty("1")
+	ok, v := list.Back().Value.(*InmemoryConfiguration).GetProperty("1")
 	assert.True(t, ok)
 	assert.Equal(t, "2", v)
 }

common/constant/default.go

@@ -18,8 +18,14 @@
 package constant
 
 const (
-	DUBBO = "dubbo"
+	DUBBO             = "dubbo"
+	PROVIDER_PROTOCOL = "provider"
+	//compatible with 2.6.x
+	OVERRIDE_PROTOCOL = "override"
+	EMPTY_PROTOCOL    = "empty"
+	ROUTER_PROTOCOL   = "router"
 )
+
 const (
 	DEFAULT_WEIGHT = 100     //
 	DEFAULT_WARMUP = 10 * 60 // in java here is 10*60*1000 because of System.currentTimeMillis() is measured in milliseconds & in go time.Unix() is second
@@ -48,5 +54,16 @@ const (
 )
 
 const (
-	ANY_VALUE = "*"
+	ANY_VALUE           = "*"
+	ANYHOST_VALUE       = "0.0.0.0"
+	REMOVE_VALUE_PREFIX = "-"
+)
+
+const (
+	CONFIGURATORS_CATEGORY             = "configurators"
+	ROUTER_CATEGORY                    = "category"
+	DEFAULT_CATEGORY                   = PROVIDER_CATEGORY
+	DYNAMIC_CONFIGURATORS_CATEGORY     = "dynamicconfigurators"
+	APP_DYNAMIC_CONFIGURATORS_CATEGORY = "appdynamicconfigurators"
+	PROVIDER_CATEGORY                  = "providers"
 )

common/constant/key.go

@@ -22,15 +22,21 @@ const (
 )
 
 const (
-	GROUP_KEY     = "group"
-	VERSION_KEY   = "version"
-	INTERFACE_KEY = "interface"
-	PATH_KEY      = "path"
-	SERVICE_KEY   = "service"
-	METHODS_KEY   = "methods"
-	TIMEOUT_KEY   = "timeout"
-	BEAN_NAME_KEY = "bean.name"
-	GENERIC_KEY   = "generic"
+	GROUP_KEY              = "group"
+	VERSION_KEY            = "version"
+	INTERFACE_KEY          = "interface"
+	PATH_KEY               = "path"
+	SERVICE_KEY            = "service"
+	METHODS_KEY            = "methods"
+	TIMEOUT_KEY            = "timeout"
+	CATEGORY_KEY           = "category"
+	CHECK_KEY              = "check"
+	ENABLED_KEY            = "enabled"
+	SIDE_KEY               = "side"
+	OVERRIDE_PROVIDERS_KEY = "providerAddresses"
+	BEAN_NAME_KEY          = "bean.name"
+	GENERIC_KEY            = "generic"
+	CLASSIFIER_KEY         = "classifier"
 )
 
 const (
@@ -79,16 +85,23 @@ const (
 )
 
 const (
-	CONFIG_NAMESPACE_KEY = "config.namespace"
-	CONFIG_TIMEOUT_KET   = "config.timeout"
+	CONFIG_NAMESPACE_KEY  = "config.namespace"
+	CONFIG_TIMEOUT_KET    = "config.timeout"
+	CONFIG_VERSION_KEY    = "configVersion"
+	COMPATIBLE_CONFIG_KEY = "compatible_config"
 )
 const (
-	RegistryConfigPrefix  = "dubbo.registries."
-	ReferenceConfigPrefix = "dubbo.reference."
-	ServiceConfigPrefix   = "dubbo.service."
-	ProtocolConfigPrefix  = "dubbo.protocols."
-	ProviderConfigPrefix  = "dubbo.provider."
-	ConsumerConfigPrefix  = "dubbo.consumer."
+	RegistryConfigPrefix       = "dubbo.registries."
+	SingleRegistryConfigPrefix = "dubbo.registry."
+	ReferenceConfigPrefix      = "dubbo.reference."
+	ServiceConfigPrefix        = "dubbo.service."
+	ProtocolConfigPrefix       = "dubbo.protocols."
+	ProviderConfigPrefix       = "dubbo.provider."
+	ConsumerConfigPrefix       = "dubbo.consumer."
+)
+
+const (
+	CONFIGURATORS_SUFFIX = ".configurators"
 )
 
 const (

examples/configcenter/zookeeper/jsonrpc/with-configcenter-go-client/app/user.go → common/extension/configurator.go

@@ -15,49 +15,46 @@
  * limitations under the License.
  */
 
-package main
+package extension
 
 import (
-	"context"
-	"fmt"
-	"time"
+	"github.com/apache/dubbo-go/common"
+	"github.com/apache/dubbo-go/config_center"
 )
 
-import (
-	"github.com/apache/dubbo-go/config"
-)
+const DefaultKey = "default"
 
-var userProvider = new(UserProvider)
+type getConfiguratorFunc func(url *common.URL) config_center.Configurator
 
-func init() {
-	config.SetConsumerService(userProvider)
-}
+var (
+	configurator = make(map[string]getConfiguratorFunc)
+)
 
-type JsonRPCUser struct {
-	ID   string `json:"id"`
-	Name string `json:"name"`
-	Age  int64  `json:"age"`
-	Time int64  `json:"time"`
-	Sex  string `json:"sex"`
+func SetConfigurator(name string, v getConfiguratorFunc) {
+	configurator[name] = v
 }
 
-func (u JsonRPCUser) String() string {
-	return fmt.Sprintf(
-		"User{ID:%s, Name:%s, Age:%d, Time:%s, Sex:%s}",
-		u.ID, u.Name, u.Age, time.Unix(u.Time, 0).Format("2006-01-02 15:04:05.99999"), u.Sex,
-	)
-}
+func GetConfigurator(name string, url *common.URL) config_center.Configurator {
+	if configurator[name] == nil {
+		panic("configurator for " + name + " is not existing, make sure you have import the package.")
+	}
+	return configurator[name](url)
 
-type UserProvider struct {
-	GetUsers func(req []interface{}) ([]JsonRPCUser, error)
-	GetUser  func(ctx context.Context, req []interface{}, rsp *JsonRPCUser) error
-	GetUser0 func(id string, name string) (JsonRPCUser, error)
-	GetUser1 func(ctx context.Context, req []interface{}, rsp *JsonRPCUser) error
-	GetUser2 func(ctx context.Context, req []interface{}, rsp *JsonRPCUser) error `dubbo:"getUser"`
-	GetUser3 func() error
-	Echo     func(ctx context.Context, req interface{}) (interface{}, error) // Echo represent EchoFilter will be used
+}
+func SetDefaultConfigurator(v getConfiguratorFunc) {
+	configurator[DefaultKey] = v
 }
 
-func (u *UserProvider) Reference() string {
-	return "UserProvider"
+func GetDefaultConfigurator(url *common.URL) config_center.Configurator {
+	if configurator[DefaultKey] == nil {
+		panic("configurator for default is not existing, make sure you have import the package.")
+	}
+	return configurator[DefaultKey](url)
+
+}
+func GetDefaultConfiguratorFunc() getConfiguratorFunc {
+	if configurator[DefaultKey] == nil {
+		panic("configurator for default is not existing, make sure you have import the package.")
+	}
+	return configurator[DefaultKey]
 }

common/url.go

@@ -31,6 +31,8 @@ import (
 )
 
 import (
+	"github.com/dubbogo/gost/container"
+	"github.com/jinzhu/copier"
 	perrors "github.com/pkg/errors"
 )
 
@@ -230,13 +232,37 @@ func (c URL) URLEqual(url URL) bool {
 	if cKey != urlKey {
 		return false
 	}
+	if url.GetParam(constant.ENABLED_KEY, "true") != "true" && url.GetParam(constant.ENABLED_KEY, "") != constant.ANY_VALUE {
+		return false
+	}
+	//TODO :may need add interface key any value condition
+	if !isMatchCategory(url.GetParam(constant.CATEGORY_KEY, constant.DEFAULT_CATEGORY), c.GetParam(constant.CATEGORY_KEY, constant.DEFAULT_CATEGORY)) {
+		return false
+	}
 	return true
 }
-
+func isMatchCategory(category1 string, category2 string) bool {
+	if len(category2) == 0 {
+		return category1 == constant.DEFAULT_CATEGORY
+	} else if strings.Contains(category2, constant.ANY_VALUE) {
+		return true
+	} else if strings.Contains(category2, constant.REMOVE_VALUE_PREFIX) {
+		return !strings.Contains(category2, constant.REMOVE_VALUE_PREFIX+category1)
+	} else {
+		return strings.Contains(category2, category1)
+	}
+}
 func (c URL) String() string {
-	buildString := fmt.Sprintf(
-		"%s://%s:%s@%s:%s%s?",
-		c.Protocol, c.Username, c.Password, c.Ip, c.Port, c.Path)
+	var buildString string
+	if len(c.Username) == 0 && len(c.Password) == 0 {
+		buildString = fmt.Sprintf(
+			"%s://%s:%s%s?",
+			c.Protocol, c.Ip, c.Port, c.Path)
+	} else {
+		buildString = fmt.Sprintf(
+			"%s://%s:%s@%s:%s%s?",
+			c.Protocol, c.Username, c.Password, c.Ip, c.Port, c.Path)
+	}
 	c.paramsLock.RLock()
 	buildString += c.params.Encode()
 	c.paramsLock.RUnlock()
@@ -274,6 +300,11 @@ func (c URL) ServiceKey() string {
 	return buf.String()
 }
 
+func (c *URL) EncodedServiceKey() string {
+	serviceKey := c.ServiceKey()
+	return strings.Replace(serviceKey, "/", "*", 1)
+}
+
 func (c URL) Context() context.Context {
 	return c.ctx
 }
@@ -322,6 +353,11 @@ func (c URL) GetParam(s string, d string) string {
 	c.paramsLock.RUnlock()
 	return r
 }
+
+func (c URL) GetParams() url.Values {
+	return c.params
+}
+
 func (c URL) GetParamAndDecoded(key string) (string, error) {
 	c.paramsLock.RLock()
 	defer c.paramsLock.RUnlock()
@@ -398,6 +434,21 @@ func (c URL) GetMethodParam(method string, key string, d string) string {
 	return r
 }
 
+func (c *URL) RemoveParams(set *container.HashSet) {
+	c.paramsLock.Lock()
+	defer c.paramsLock.Unlock()
+	for k := range set.Items {
+		s := k.(string)
+		delete(c.params, s)
+	}
+}
+
+func (c *URL) SetParams(m url.Values) {
+	for k := range m {
+		c.SetParam(k, m.Get(k))
+	}
+}
+
 // ToMap transfer URL to Map
 func (c URL) ToMap() map[string]string {
 
@@ -442,8 +493,9 @@ func (c URL) ToMap() map[string]string {
 // configuration  > reference config >service config
 //  in this function we should merge the reference local url config into the service url from registry.
 //TODO configuration merge, in the future , the configuration center's config should merge too.
-func MergeUrl(serviceUrl URL, referenceUrl *URL) URL {
-	mergedUrl := serviceUrl
+
+func MergeUrl(serviceUrl *URL, referenceUrl *URL) *URL {
+	mergedUrl := serviceUrl.Clone()
 
 	//iterator the referenceUrl if serviceUrl not have the key ,merge in
 	referenceUrl.RangeParams(func(key, value string) bool {
@@ -470,8 +522,18 @@ func MergeUrl(serviceUrl URL, referenceUrl *URL) URL {
 
 	return mergedUrl
 }
+func (c *URL) Clone() *URL {
+	newUrl := &URL{}
+	copier.Copy(newUrl, c)
+	newUrl.params = url.Values{}
+	c.RangeParams(func(key, value string) bool {
+		newUrl.SetParam(key, value)
+		return true
+	})
+	return newUrl
+}
 
-func mergeNormalParam(mergedUrl URL, referenceUrl *URL, paramKeys []string) []func(method string) {
+func mergeNormalParam(mergedUrl *URL, referenceUrl *URL, paramKeys []string) []func(method string) {
 	var methodConfigMergeFcn = []func(method string){}
 	for _, paramKey := range paramKeys {
 		if v := referenceUrl.GetParam(paramKey, ""); len(v) > 0 {

common/url_test.go

@@ -56,7 +56,7 @@ func TestNewURLWithOptions(t *testing.T) {
 }
 
 func TestURL(t *testing.T) {
-	u, err := NewURL(context.TODO(), "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&"+
+	u, err := NewURL(context.TODO(), "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&"+
 		"application=BDTService&category=providers&default.timeout=10000&dubbo=dubbo-provider-golang-1.0.0&"+
 		"environment=dev&interface=com.ikurento.user.UserProvider&ip=192.168.56.1&methods=GetUser%2C&"+
 		"module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&"+
@@ -76,14 +76,14 @@ func TestURL(t *testing.T) {
 		"2C&module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000&t"+
 		"imestamp=1556509797245", u.params.Encode())
 
-	assert.Equal(t, "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&application=BDTServi"+
+	assert.Equal(t, "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&application=BDTServi"+
 		"ce&category=providers&default.timeout=10000&dubbo=dubbo-provider-golang-1.0.0&environment=dev&interface=com.ikure"+
 		"nto.user.UserProvider&ip=192.168.56.1&methods=GetUser%2C&module=dubbogo+user-info+server&org=ikurento.com&owner="+
 		"ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000&timestamp=1556509797245", u.String())
 }
 
 func TestURLWithoutSchema(t *testing.T) {
-	u, err := NewURL(context.TODO(), "@127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&"+
+	u, err := NewURL(context.TODO(), "127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&"+
 		"application=BDTService&category=providers&default.timeout=10000&dubbo=dubbo-provider-golang-1.0.0&"+
 		"environment=dev&interface=com.ikurento.user.UserProvider&ip=192.168.56.1&methods=GetUser%2C&"+
 		"module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&"+
@@ -103,20 +103,20 @@ func TestURLWithoutSchema(t *testing.T) {
 		"2C&module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000&t"+
 		"imestamp=1556509797245", u.params.Encode())
 
-	assert.Equal(t, "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&application=BDTServi"+
+	assert.Equal(t, "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&application=BDTServi"+
 		"ce&category=providers&default.timeout=10000&dubbo=dubbo-provider-golang-1.0.0&environment=dev&interface=com.ikure"+
 		"nto.user.UserProvider&ip=192.168.56.1&methods=GetUser%2C&module=dubbogo+user-info+server&org=ikurento.com&owner="+
 		"ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000&timestamp=1556509797245", u.String())
 }
 
 func TestURL_URLEqual(t *testing.T) {
-	u1, err := NewURL(context.TODO(), "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0")
+	u1, err := NewURL(context.TODO(), "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0")
 	assert.NoError(t, err)
-	u2, err := NewURL(context.TODO(), "dubbo://:@127.0.0.2:20001/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0")
+	u2, err := NewURL(context.TODO(), "dubbo://127.0.0.2:20001/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0")
 	assert.NoError(t, err)
 	assert.True(t, u1.URLEqual(u2))
 
-	u3, err := NewURL(context.TODO(), "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
+	u3, err := NewURL(context.TODO(), "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
 	assert.NoError(t, err)
 	assert.False(t, u1.URLEqual(u3))
 }
@@ -231,10 +231,31 @@ func TestMergeUrl(t *testing.T) {
 	referenceUrl, _ := NewURL(context.TODO(), "mock1://127.0.0.1:1111", WithParams(referenceUrlParams), WithMethods([]string{"testMethod"}))
 	serviceUrl, _ := NewURL(context.TODO(), "mock2://127.0.0.1:20000", WithParams(serviceUrlParams))
 
-	mergedUrl := MergeUrl(serviceUrl, &referenceUrl)
+	mergedUrl := MergeUrl(&serviceUrl, &referenceUrl)
 	assert.Equal(t, "random", mergedUrl.GetParam(constant.CLUSTER_KEY, ""))
 	assert.Equal(t, "1", mergedUrl.GetParam("test2", ""))
 	assert.Equal(t, "1", mergedUrl.GetParam("test3", ""))
 	assert.Equal(t, "1", mergedUrl.GetParam(constant.RETRIES_KEY, ""))
 	assert.Equal(t, "1", mergedUrl.GetParam("methods.testMethod."+constant.RETRIES_KEY, ""))
 }
+
+func TestURL_SetParams(t *testing.T) {
+	u1, err := NewURL(context.TODO(), "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0&configVersion=1.0")
+	assert.NoError(t, err)
+	params := url.Values{}
+	params.Set("key", "3")
+	u1.SetParams(params)
+	assert.Equal(t, "3", u1.GetParam("key", ""))
+	assert.Equal(t, "2.6.0", u1.GetParam("version", ""))
+}
+
+func TestClone(t *testing.T) {
+	u1, err := NewURL(context.TODO(), "dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0&configVersion=1.0")
+	assert.NoError(t, err)
+	u2 := u1.Clone()
+	assert.Equal(t, u2.Protocol, "dubbo")
+	assert.Equal(t, "1.0", u2.GetParam("configVersion", ""))
+	u2.Protocol = "provider"
+	assert.Equal(t, u1.Protocol, "dubbo")
+	assert.Equal(t, u2.Protocol, "provider")
+}

config/application_config.go

@@ -17,7 +17,13 @@
 
 package config
 
-import "github.com/apache/dubbo-go/common/constant"
+import (
+	"github.com/creasty/defaults"
+)
+
+import (
+	"github.com/apache/dubbo-go/common/constant"
+)
 
 type ApplicationConfig struct {
 	Organization string `yaml:"organization"  json:"organization,omitempty" property:"organization"`
@@ -37,3 +43,13 @@ func (c *ApplicationConfig) Id() string {
 func (c *ApplicationConfig) SetId(id string) {
 
 }
+func (c *ApplicationConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	if err := defaults.Set(c); err != nil {
+		return err
+	}
+	type plain ApplicationConfig
+	if err := unmarshal((*plain)(c)); err != nil {
+		return err
+	}
+	return nil
+}

config/base_config.go

@@ -20,10 +20,13 @@ import (
 	"context"
 	"reflect"
 	"strconv"
+	"strings"
 )
+
 import (
 	perrors "github.com/pkg/errors"
 )
+
 import (
 	"github.com/apache/dubbo-go/common"
 	"github.com/apache/dubbo-go/common/config"
@@ -60,6 +63,7 @@ func (c *BaseConfig) prepareEnvironment() error {
 
 	factory := extension.GetConfigCenterFactory(c.ConfigCenterConfig.Protocol)
 	dynamicConfig, err := factory.GetDynamicConfiguration(c.configCenterUrl)
+	config.GetEnvInstance().SetDynamicConfiguration(dynamicConfig)
 	if err != nil {
 		logger.Errorf("Get dynamic configuration error , error message is %v", err)
 		return perrors.WithStack(err)
@@ -69,43 +73,109 @@ func (c *BaseConfig) prepareEnvironment() error {
 		logger.Errorf("Get config content in dynamic configuration error , error message is %v", err)
 		return perrors.WithStack(err)
 	}
+	var appGroup string
+	var appContent string
+	if providerConfig != nil && providerConfig.ApplicationConfig != nil &&
+		reflect.ValueOf(c.fatherConfig).Elem().Type().Name() == "ProviderConfig" {
+		appGroup = providerConfig.ApplicationConfig.Name
+	} else if consumerConfig != nil && consumerConfig.ApplicationConfig != nil &&
+		reflect.ValueOf(c.fatherConfig).Elem().Type().Name() == "ConsumerConfig" {
+		appGroup = consumerConfig.ApplicationConfig.Name
+	}
+
+	if len(appGroup) != 0 {
+		configFile := c.ConfigCenterConfig.AppConfigFile
+		if len(configFile) == 0 {
+			configFile = c.ConfigCenterConfig.ConfigFile
+		}
+		appContent, err = dynamicConfig.GetConfig(configFile, config_center.WithGroup(appGroup))
+	}
+	//global config file
 	mapContent, err := dynamicConfig.Parser().Parse(content)
 	if err != nil {
 		return perrors.WithStack(err)
 	}
 	config.GetEnvInstance().UpdateExternalConfigMap(mapContent)
+
+	//appGroup config file
+	if len(appContent) != 0 {
+		appMapConent, err := dynamicConfig.Parser().Parse(appContent)
+		if err != nil {
+			return perrors.WithStack(err)
+		}
+		config.GetEnvInstance().UpdateAppExternalConfigMap(appMapConent)
+	}
+
 	return nil
 }
 
-func getKeyPrefix(val reflect.Value, id reflect.Value) string {
+func getKeyPrefix(val reflect.Value) []string {
 	var (
 		prefix string
-		idStr  string
 	)
-	if id.Kind() == reflect.String {
-		idStr = id.Interface().(string)
-	}
 
 	if val.CanAddr() {
 		prefix = val.Addr().MethodByName("Prefix").Call(nil)[0].String()
 	} else {
 		prefix = val.MethodByName("Prefix").Call(nil)[0].String()
 	}
+	var retPrefixs []string
+
+	for _, pfx := range strings.Split(prefix, "|") {
+
+		retPrefixs = append(retPrefixs, pfx)
 
-	if idStr != "" {
-		return prefix + idStr + "."
-	} else {
-		return prefix
 	}
-}
+	return retPrefixs
 
+}
+func getPtrElement(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+		if v.Kind() == reflect.Ptr {
+			return getPtrElement(v)
+		}
+	}
+	return v
+}
 func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryConfiguration) {
 	for i := 0; i < val.NumField(); i++ {
 		if key := val.Type().Field(i).Tag.Get("property"); key != "-" && key != "" {
 			f := val.Field(i)
 			if f.IsValid() {
 				setBaseValue := func(f reflect.Value) {
-					ok, value := config.GetProperty(getKeyPrefix(val, id) + key)
+
+					var (
+						ok    bool
+						value string
+						idStr string
+					)
+
+					prefixs := getKeyPrefix(val)
+
+					if id.Kind() == reflect.String {
+						idStr = id.Interface().(string)
+					}
+
+					for _, pfx := range prefixs {
+
+						if len(pfx) > 0 {
+							if len(idStr) > 0 {
+								ok, value = config.GetProperty(pfx + idStr + "." + key)
+							}
+							if len(value) == 0 || !ok {
+								ok, value = config.GetProperty(pfx + key)
+							}
+
+						} else {
+							ok, value = config.GetProperty(key)
+						}
+
+						if ok {
+							break
+						}
+
+					}
 					if ok {
 						switch f.Kind() {
 						case reflect.Int64:
@@ -151,12 +221,12 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
 
 				}
 
-				setBaseValue(f)
 				if f.Kind() == reflect.Ptr {
-					if f.Elem().Kind() == reflect.Struct {
-						setFieldValue(f.Elem(), reflect.Value{}, config)
+					f = getPtrElement(f)
+					if f.Kind() == reflect.Struct {
+						setFieldValue(f, reflect.Value{}, config)
 					} else {
-						setBaseValue(f.Elem())
+						setBaseValue(f)
 					}
 				}
 
@@ -167,10 +237,11 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
 					for i := 0; i < f.Len(); i++ {
 						e := f.Index(i)
 						if e.Kind() == reflect.Ptr {
-							if e.Elem().Kind() == reflect.Struct {
-								setFieldValue(e.Elem(), reflect.Value{}, config)
+							e = getPtrElement(e)
+							if e.Kind() == reflect.Struct {
+								setFieldValue(e, reflect.Value{}, config)
 							} else {
-								setBaseValue(e.Elem())
+								setBaseValue(e)
 							}
 						}
 
@@ -183,10 +254,16 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
 						//initiate config
 						s := reflect.New(f.Type().Elem().Elem())
 						prefix := s.MethodByName("Prefix").Call(nil)[0].String()
-						m := config.GetSubProperty(prefix)
-						for k := range m {
-							f.SetMapIndex(reflect.ValueOf(k), reflect.New(f.Type().Elem().Elem()))
+						for _, pfx := range strings.Split(prefix, "|") {
+							m := config.GetSubProperty(pfx)
+							if m != nil {
+								for k := range m {
+									f.SetMapIndex(reflect.ValueOf(k), reflect.New(f.Type().Elem().Elem()))
+								}
+							}
+
 						}
+
 					}
 
 					//iter := f.MapRange()
@@ -195,10 +272,11 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
 						v := f.MapIndex(k)
 						switch v.Kind() {
 						case reflect.Ptr:
-							if v.Elem().Kind() == reflect.Struct {
-								setFieldValue(v.Elem(), k, config)
+							v = getPtrElement(v)
+							if v.Kind() == reflect.Struct {
+								setFieldValue(v, k, config)
 							} else {
-								setBaseValue(v.Elem())
+								setBaseValue(v)
 							}
 						case reflect.Int64, reflect.String, reflect.Bool, reflect.Float64:
 							setBaseValue(v)
@@ -207,6 +285,7 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
 						}
 					}
 				}
+				setBaseValue(f)
 
 			}
 		}
@@ -214,8 +293,13 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
 }
 func (c *BaseConfig) fresh() {
 	configList := config.GetEnvInstance().Configuration()
-	config := configList.Front().Value.(*config.InmemoryConfiguration)
+	for element := configList.Front(); element != nil; element = element.Next() {
+		config := element.Value.(*config.InmemoryConfiguration)
+		c.freshInternalConfig(config)
+	}
+}
 
+func (c *BaseConfig) freshInternalConfig(config *config.InmemoryConfiguration) {
 	//reflect to init struct
 	tp := reflect.ValueOf(c.fatherConfig).Elem().Type()
 	initializeStruct(tp, reflect.ValueOf(c.fatherConfig).Elem())

config/base_config_test.go

@@ -125,6 +125,258 @@ func Test_refresh(t *testing.T) {
 	assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
 }
 
+func Test_appExternal_refresh(t *testing.T) {
+	c := &BaseConfig{}
+	mockMap := map[string]string{}
+	mockMap["dubbo.registries.shanghai_reg1.protocol"] = "mock100"
+	mockMap["dubbo.reference.com.MockService.MockService.retries"] = "10"
+	mockMap["dubbo.reference.com.MockService.retries"] = "5"
+	mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
+	mockMap["dubbo.consumer.check"] = "false"
+	mockMap["dubbo.application.name"] = "dubbo"
+
+	config.GetEnvInstance().UpdateAppExternalConfigMap(mockMap)
+	mockMap["dubbo.consumer.check"] = "true"
+	config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
+	father := &ConsumerConfig{
+		Check: &[]bool{true}[0],
+		ApplicationConfig: &ApplicationConfig{
+			Organization: "dubbo_org",
+			Name:         "dubbo",
+			Module:       "module",
+			Version:      "2.6.0",
+			Owner:        "dubbo",
+			Environment:  "test"},
+		Registries: map[string]*RegistryConfig{
+			//"shanghai_reg1": {
+			//	id:         "shanghai_reg1",
+			//	Protocol:   "mock",
+			//	TimeoutStr: "2s",
+			//	Group:      "shanghai_idc",
+			//	Address:    "127.0.0.1:2181",
+			//	Username:   "user1",
+			//	Password:   "pwd1",
+			//},
+			"shanghai_reg2": {
+				Protocol:   "mock",
+				TimeoutStr: "2s",
+				Group:      "shanghai_idc",
+				Address:    "127.0.0.2:2181",
+				Username:   "user1",
+				Password:   "pwd1",
+			},
+			"hangzhou_reg1": {
+				Protocol:   "mock",
+				TimeoutStr: "2s",
+				Group:      "hangzhou_idc",
+				Address:    "127.0.0.3:2181",
+				Username:   "user1",
+				Password:   "pwd1",
+			},
+			"hangzhou_reg2": {
+				Protocol:   "mock",
+				TimeoutStr: "2s",
+				Group:      "hangzhou_idc",
+				Address:    "127.0.0.4:2181",
+				Username:   "user1",
+				Password:   "pwd1",
+			},
+		},
+		References: map[string]*ReferenceConfig{
+			"MockService": {
+				InterfaceName: "com.MockService",
+				Protocol:      "mock",
+				Cluster:       "failover",
+				Loadbalance:   "random",
+				Retries:       "3",
+				Group:         "huadong_idc",
+				Version:       "1.0.0",
+				Methods: []*MethodConfig{
+					{
+						InterfaceId:   "MockService",
+						InterfaceName: "com.MockService",
+						Name:          "GetUser",
+						Retries:       "2",
+						Loadbalance:   "random",
+					},
+					{
+						InterfaceId:   "MockService",
+						InterfaceName: "com.MockService",
+						Name:          "GetUser1",
+						Retries:       "2",
+						Loadbalance:   "random",
+					},
+				},
+			},
+		},
+	}
+
+	c.SetFatherConfig(father)
+	c.fresh()
+	assert.Equal(t, "mock100", father.Registries["shanghai_reg1"].Protocol)
+	assert.Equal(t, "10", father.References["MockService"].Retries)
+
+	assert.Equal(t, "10", father.References["MockService"].Methods[0].Retries)
+	assert.Equal(t, &[]bool{true}[0], father.Check)
+	assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
+}
+
+func Test_appExternalWithoutId_refresh(t *testing.T) {
+	c := &BaseConfig{}
+	mockMap := map[string]string{}
+	mockMap["dubbo.registries.shanghai_reg1.protocol"] = "mock100"
+	mockMap["dubbo.reference.com.MockService.retries"] = "10"
+	mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
+	mockMap["dubbo.consumer.check"] = "false"
+	mockMap["dubbo.application.name"] = "dubbo"
+
+	config.GetEnvInstance().UpdateAppExternalConfigMap(mockMap)
+	mockMap["dubbo.consumer.check"] = "true"
+	config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
+	father := &ConsumerConfig{
+		Check: &[]bool{true}[0],
+		ApplicationConfig: &ApplicationConfig{
+			Organization: "dubbo_org",
+			Name:         "dubbo",
+			Module:       "module",
+			Version:      "2.6.0",
+			Owner:        "dubbo",
+			Environment:  "test"},
+		Registries: map[string]*RegistryConfig{
+			//"shanghai_reg1": {
+			//	id:         "shanghai_reg1",
+			//	Protocol:   "mock",
+			//	TimeoutStr: "2s",
+			//	Group:      "shanghai_idc",
+			//	Address:    "127.0.0.1:2181",
+			//	Username:   "user1",
+			//	Password:   "pwd1",
+			//},
+			"shanghai_reg2": {
+				Protocol:   "mock",
+				TimeoutStr: "2s",
+				Group:      "shanghai_idc",
+				Address:    "127.0.0.2:2181",
+				Username:   "user1",
+				Password:   "pwd1",
+			},
+			"hangzhou_reg1": {
+				Protocol:   "mock",
+				TimeoutStr: "2s",
+				Group:      "hangzhou_idc",
+				Address:    "127.0.0.3:2181",
+				Username:   "user1",
+				Password:   "pwd1",
+			},
+			"hangzhou_reg2": {
+				Protocol:   "mock",
+				TimeoutStr: "2s",
+				Group:      "hangzhou_idc",
+				Address:    "127.0.0.4:2181",
+				Username:   "user1",
+				Password:   "pwd1",
+			},
+		},
+		References: map[string]*ReferenceConfig{
+			"MockService": {
+				InterfaceName: "com.MockService",
+				Protocol:      "mock",
+				Cluster:       "failover",
+				Loadbalance:   "random",
+				Retries:       "3",
+				Group:         "huadong_idc",
+				Version:       "1.0.0",
+				Methods: []*MethodConfig{
+					{
+						InterfaceId:   "MockService",
+						InterfaceName: "com.MockService",
+						Name:          "GetUser",
+						Retries:       "3",
+						Loadbalance:   "random",
+					},
+					{
+						InterfaceId:   "MockService",
+						InterfaceName: "com.MockService",
+						Name:          "GetUser1",
+						Retries:       "2",
+						Loadbalance:   "random",
+					},
+				},
+			},
+		},
+	}
+
+	c.SetFatherConfig(father)
+	c.fresh()
+	assert.Equal(t, "mock100", father.Registries["shanghai_reg1"].Protocol)
+	assert.Equal(t, "10", father.References["MockService"].Retries)
+
+	assert.Equal(t, "10", father.References["MockService"].Methods[0].Retries)
+	assert.Equal(t, &[]bool{true}[0], father.Check)
+	assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
+}
+
+func Test_refresh_singleRegistry(t *testing.T) {
+	c := &BaseConfig{}
+	mockMap := map[string]string{}
+	mockMap["dubbo.registry.address"] = "mock100://127.0.0.1:2181"
+	mockMap["dubbo.reference.com.MockService.MockService.retries"] = "10"
+	mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
+	mockMap["dubbo.consumer.check"] = "false"
+	mockMap["dubbo.application.name"] = "dubbo"
+
+	config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
+
+	father := &ConsumerConfig{
+		Check: &[]bool{true}[0],
+		ApplicationConfig: &ApplicationConfig{
+			Organization: "dubbo_org",
+			Name:         "dubbo",
+			Module:       "module",
+			Version:      "2.6.0",
+			Owner:        "dubbo",
+			Environment:  "test"},
+		Registries: map[string]*RegistryConfig{},
+		Registry:   &RegistryConfig{},
+		References: map[string]*ReferenceConfig{
+			"MockService": {
+				InterfaceName: "com.MockService",
+				Protocol:      "mock",
+				Cluster:       "failover",
+				Loadbalance:   "random",
+				Retries:       "3",
+				Group:         "huadong_idc",
+				Version:       "1.0.0",
+				Methods: []*MethodConfig{
+					{
+						InterfaceId:   "MockService",
+						InterfaceName: "com.MockService",
+						Name:          "GetUser",
+						Retries:       "2",
+						Loadbalance:   "random",
+					},
+					{
+						InterfaceId:   "MockService",
+						InterfaceName: "com.MockService",
+						Name:          "GetUser1",
+						Retries:       "2",
+						Loadbalance:   "random",
+					},
+				},
+			},
+		},
+	}
+
+	c.SetFatherConfig(father)
+	c.fresh()
+	assert.Equal(t, "mock100://127.0.0.1:2181", father.Registry.Address)
+	assert.Equal(t, "10", father.References["MockService"].Retries)
+
+	assert.Equal(t, "10", father.References["MockService"].Methods[0].Retries)
+	assert.Equal(t, &[]bool{false}[0], father.Check)
+	assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
+}
+
 func Test_refreshProvider(t *testing.T) {
 	c := &BaseConfig{}
 	mockMap := map[string]string{}
@@ -233,7 +485,7 @@ func Test_startConfigCenter(t *testing.T) {
 	}}
 	err := c.startConfigCenter(context.Background())
 	assert.NoError(t, err)
-	b, v := config.GetEnvInstance().Configuration().Front().Value.(*config.InmemoryConfiguration).GetProperty("dubbo.application.organization")
+	b, v := config.GetEnvInstance().Configuration().Back().Value.(*config.InmemoryConfiguration).GetProperty("dubbo.application.organization")
 	assert.True(t, b)
 	assert.Equal(t, "ikurento.com", v)
 }

config/config_center_config.go

@@ -22,15 +22,31 @@ import (
 	"time"
 )
 
+import (
+	"github.com/creasty/defaults"
+)
+
 type ConfigCenterConfig struct {
-	context    context.Context
-	Protocol   string `required:"true"  yaml:"protocol"  json:"protocol,omitempty"`
-	Address    string `yaml:"address" json:"address,omitempty"`
-	Cluster    string `yaml:"cluster" json:"cluster,omitempty"`
-	Group      string `default:"dubbo" yaml:"group" json:"group,omitempty"`
-	Username   string `yaml:"username" json:"username,omitempty"`
-	Password   string `yaml:"password" json:"password,omitempty"`
-	ConfigFile string `default:"dubbo.properties" yaml:"config_file"  json:"config_file,omitempty"`
-	TimeoutStr string `yaml:"timeout"  json:"timeout,omitempty"`
-	timeout    time.Duration
+	context       context.Context
+	Protocol      string `required:"true"  yaml:"protocol"  json:"protocol,omitempty"`
+	Address       string `yaml:"address" json:"address,omitempty"`
+	Cluster       string `yaml:"cluster" json:"cluster,omitempty"`
+	Group         string `default:"dubbo" yaml:"group" json:"group,omitempty"`
+	Username      string `yaml:"username" json:"username,omitempty"`
+	Password      string `yaml:"password" json:"password,omitempty"`
+	ConfigFile    string `default:"dubbo.properties" yaml:"config_file"  json:"config_file,omitempty"`
+	AppConfigFile string `default:"dubbo.properties" yaml:"app_config_file"  json:"app_config_file,omitempty"`
+	TimeoutStr    string `yaml:"timeout"  json:"timeout,omitempty"`
+	timeout       time.Duration
+}
+
+func (c *ConfigCenterConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	if err := defaults.Set(c); err != nil {
+		return err
+	}
+	type plain ConfigCenterConfig
+	if err := unmarshal((*plain)(c)); err != nil {
+		return err
+	}
+	return nil
 }

config/config_loader.go

@@ -54,6 +54,19 @@ func init() {
 		providerConfig = nil
 	}
 }
+func checkRegistries(registries map[string]*RegistryConfig, singleRegistry *RegistryConfig) {
+	if len(registries) == 0 && singleRegistry != nil {
+		registries[constant.DEFAULT_KEY] = singleRegistry
+	}
+}
+
+func checkApplicationName(config *ApplicationConfig) {
+	if config == nil || len(config.Name) == 0 {
+		errMsg := "application config must not be nil, pls check your configuration"
+		logger.Errorf(errMsg)
+		panic(errMsg)
+	}
+}
 
 // Dubbo Init
 func Load() {
@@ -61,9 +74,11 @@ func Load() {
 	if consumerConfig == nil {
 		logger.Warnf("consumerConfig is nil!")
 	} else {
+		checkApplicationName(consumerConfig.ApplicationConfig)
 		if err := configCenterRefreshConsumer(); err != nil {
 			logger.Errorf("[consumer config center refresh] %#v", err)
 		}
+		checkRegistries(consumerConfig.Registries, consumerConfig.Registry)
 		for key, ref := range consumerConfig.References {
 			if ref.Generic {
 				genericService := NewGenericService(key)
@@ -92,7 +107,9 @@ func Load() {
 						checkok = false
 						count++
 						if count > maxWait {
-							panic(fmt.Sprintf("Failed to check the status of the service %v . No provider available for the service to the consumer use dubbo version %v", refconfig.InterfaceName, constant.Version))
+							errMsg := fmt.Sprintf("Failed to check the status of the service %v . No provider available for the service to the consumer use dubbo version %v", refconfig.InterfaceName, constant.Version)
+							logger.Error(errMsg)
+							panic(errMsg)
 						}
 						time.Sleep(time.Second * 1)
 						break
@@ -113,9 +130,11 @@ func Load() {
 	if providerConfig == nil {
 		logger.Warnf("providerConfig is nil!")
 	} else {
+		checkApplicationName(providerConfig.ApplicationConfig)
 		if err := configCenterRefreshProvider(); err != nil {
 			logger.Errorf("[provider config center refresh] %#v", err)
 		}
+		checkRegistries(providerConfig.Registries, providerConfig.Registry)
 		for key, svs := range providerConfig.Services {
 			rpcService := GetProviderService(key)
 			if rpcService == nil {

config/config_loader_test.go

@@ -29,6 +29,8 @@ import (
 import (
 	"github.com/apache/dubbo-go/cluster/cluster_impl"
 	"github.com/apache/dubbo-go/common"
+	"github.com/apache/dubbo-go/common/config"
+	"github.com/apache/dubbo-go/common/constant"
 	"github.com/apache/dubbo-go/common/extension"
 	"github.com/apache/dubbo-go/common/proxy/proxy_factory"
 	"github.com/apache/dubbo-go/config_center"
@@ -58,8 +60,36 @@ func TestConfigLoader(t *testing.T) {
 }
 
 func TestLoad(t *testing.T) {
-	doInit()
-	doinit()
+	doInitConsumer()
+	doInitProvider()
+
+	ms := &MockService{}
+	SetConsumerService(ms)
+	SetProviderService(ms)
+
+	extension.SetProtocol("registry", GetProtocol)
+	extension.SetCluster("registryAware", cluster_impl.NewRegistryAwareCluster)
+	extension.SetProxyFactory("default", proxy_factory.NewDefaultProxyFactory)
+
+	Load()
+
+	assert.Equal(t, ms, GetRPCService(ms.Reference()))
+	ms2 := &struct {
+		MockService
+	}{}
+	RPCService(ms2)
+	assert.NotEqual(t, ms2, GetRPCService(ms2.Reference()))
+
+	conServices = map[string]common.RPCService{}
+	proServices = map[string]common.RPCService{}
+	common.ServiceMap.UnRegister("mock", "MockService")
+	consumerConfig = nil
+	providerConfig = nil
+}
+
+func TestLoadWithSingleReg(t *testing.T) {
+	doInitConsumerWithSingleRegistry()
+	doInitProviderWithSingleRegistry()
 
 	ms := &MockService{}
 	SetConsumerService(ms)
@@ -86,8 +116,8 @@ func TestLoad(t *testing.T) {
 }
 
 func TestWithNoRegLoad(t *testing.T) {
-	doInit()
-	doinit()
+	doInitConsumer()
+	doInitProvider()
 	providerConfig.Services["MockService"].Registry = ""
 	consumerConfig.References["MockService"].Registry = ""
 	ms := &MockService{}
@@ -145,3 +175,60 @@ func TestConfigLoaderWithConfigCenter(t *testing.T) {
 	assert.Equal(t, "127.0.0.1:2181", consumerConfig.Registries["hangzhouzk"].Address)
 
 }
+
+func TestConfigLoaderWithConfigCenterSingleRegistry(t *testing.T) {
+	consumerConfig = nil
+	providerConfig = nil
+	config.NewEnvInstance()
+	extension.SetConfigCenterFactory("mock", func() config_center.DynamicConfigurationFactory {
+		return &config_center.MockDynamicConfigurationFactory{Content: `
+	dubbo.consumer.request_timeout=5s
+	dubbo.consumer.connect_timeout=5s
+	dubbo.application.organization=ikurento.com
+	dubbo.application.name=BDTService
+	dubbo.application.module=dubbogo user-info server
+	dubbo.application.version=0.0.1
+	dubbo.application.owner=ZX
+	dubbo.application.environment=dev
+	dubbo.registry.address=mock://127.0.0.1:2182
+	dubbo.service.com.ikurento.user.UserProvider.protocol=dubbo
+	dubbo.service.com.ikurento.user.UserProvider.interface=com.ikurento.user.UserProvider
+	dubbo.service.com.ikurento.user.UserProvider.loadbalance=random
+	dubbo.service.com.ikurento.user.UserProvider.warmup=100
+	dubbo.service.com.ikurento.user.UserProvider.cluster=failover
+	dubbo.protocols.jsonrpc1.name=jsonrpc
+	dubbo.protocols.jsonrpc1.ip=127.0.0.1
+	dubbo.protocols.jsonrpc1.port=20001
+`}
+	})
+
+	conPath, err := filepath.Abs("./testdata/consumer_config_with_configcenter.yml")
+	assert.NoError(t, err)
+	proPath, err := filepath.Abs("./testdata/provider_config.yml")
+	assert.NoError(t, err)
+
+	assert.Nil(t, consumerConfig)
+	assert.Equal(t, ConsumerConfig{}, GetConsumerConfig())
+	assert.Nil(t, providerConfig)
+	assert.Equal(t, ProviderConfig{}, GetProviderConfig())
+
+	err = ConsumerInit(conPath)
+	checkApplicationName(consumerConfig.ApplicationConfig)
+	configCenterRefreshConsumer()
+	checkRegistries(consumerConfig.Registries, consumerConfig.Registry)
+	assert.NoError(t, err)
+	err = ProviderInit(proPath)
+	checkApplicationName(providerConfig.ApplicationConfig)
+	configCenterRefreshProvider()
+	checkRegistries(providerConfig.Registries, providerConfig.Registry)
+	assert.NoError(t, err)
+
+	assert.NotNil(t, consumerConfig)
+	assert.NotEqual(t, ConsumerConfig{}, GetConsumerConfig())
+	assert.NotNil(t, providerConfig)
+	assert.NotEqual(t, ProviderConfig{}, GetProviderConfig())
+
+	assert.Equal(t, "BDTService", consumerConfig.ApplicationConfig.Name)
+	assert.Equal(t, "mock://127.0.0.1:2182", consumerConfig.Registries[constant.DEFAULT_KEY].Address)
+
+}

config/config_utils.go

@@ -21,6 +21,7 @@ import (
 	"regexp"
 	"strings"
 )
+
 import (
 	"github.com/apache/dubbo-go/common/constant"
 )

config/consumer_config.go

@@ -22,10 +22,13 @@ import (
 	"path"
 	"time"
 )
+
 import (
+	"github.com/creasty/defaults"
 	perrors "github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 )
+
 import (
 	"github.com/apache/dubbo-go/common/constant"
 	"github.com/apache/dubbo-go/common/logger"
@@ -39,7 +42,7 @@ type ConsumerConfig struct {
 	BaseConfig `yaml:",inline"`
 	Filter     string `yaml:"filter" json:"filter,omitempty" property:"filter"`
 	// application
-	ApplicationConfig *ApplicationConfig `yaml:"application_config" json:"application_config,omitempty" property:"application_config"`
+	ApplicationConfig *ApplicationConfig `yaml:"application" json:"application,omitempty" property:"application"`
 	// client
 	Connect_Timeout string `default:"100ms"  yaml:"connect_timeout" json:"connect_timeout,omitempty" property:"connect_timeout"`
 	ConnectTimeout  time.Duration
@@ -49,12 +52,24 @@ type ConsumerConfig struct {
 	ProxyFactory    string `yaml:"proxy_factory" default:"default" json:"proxy_factory,omitempty" property:"proxy_factory"`
 	Check           *bool  `yaml:"check"  json:"check,omitempty" property:"check"`
 
+	Registry     *RegistryConfig             `yaml:"registry" json:"registry,omitempty" property:"registry"`
 	Registries   map[string]*RegistryConfig  `yaml:"registries" json:"registries,omitempty" property:"registries"`
 	References   map[string]*ReferenceConfig `yaml:"references" json:"references,omitempty" property:"references"`
 	ProtocolConf interface{}                 `yaml:"protocol_conf" json:"protocol_conf,omitempty" property:"protocol_conf"`
 	FilterConf   interface{}                 `yaml:"filter_conf" json:"filter_conf,omitempty" property:"filter_conf" `
 }
 
+func (c *ConsumerConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	if err := defaults.Set(c); err != nil {
+		return err
+	}
+	type plain ConsumerConfig
+	if err := unmarshal((*plain)(c)); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (*ConsumerConfig) Prefix() string {
 	return constant.ConsumerConfigPrefix
 }

config/method_config.go

@@ -16,6 +16,10 @@
  */
 package config
 
+import (
+	"github.com/creasty/defaults"
+)
+
 import (
 	"github.com/apache/dubbo-go/common/constant"
 )
@@ -36,3 +40,14 @@ func (c *MethodConfig) Prefix() string {
 		return constant.DUBBO + "." + c.InterfaceName + "." + c.Name + "."
 	}
 }
+
+func (c *MethodConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	if err := defaults.Set(c); err != nil {
+		return err
+	}
+	type plain MethodConfig
+	if err := unmarshal((*plain)(c)); err != nil {
+		return err
+	}
+	return nil
+}

config/protocol_config.go

@@ -19,6 +19,7 @@ package config
 import (
 	"strings"
 )
+
 import (
 	"github.com/apache/dubbo-go/common/constant"
 )