Merge branch 'develop'

README.md

@@ -236,6 +236,16 @@ If you are using [apache/dubbo-go](github.com/apache/dubbo-go) and think that it
           <img width="222px"  src="https://i.gsxcdn.com/0cms/d/file/content/2020/02/5e572137d7d94.png">
         </a>
       </td>
+      <td align="center"  valign="middle">
+        <a href="http://www.51h5.com" target="_blank">
+          <img width="222px"  src="https://fs-ews.51h5.com/common/hw_220_black.png">
+        </a>
+      </td>
+      <td align="center"  valign="middle">
+        <a href="https://www.zto.com" target="_blank">
+          <img width="222px"  src="https://fscdn.zto.com/fs8/M02/B2/E4/wKhBD1-8o52Ae3GnAAASU3r62ME040.png">
+        </a>
+      </td>
     </tr>
     <tr></tr>
   </tbody>

README_CN.md

@@ -234,6 +234,16 @@ make test
           <img width="222px"  src="https://i.gsxcdn.com/0cms/d/file/content/2020/02/5e572137d7d94.png">
         </a>
       </td>
+      <td align="center"  valign="middle">
+        <a href="http://www.51h5.com" target="_blank">
+          <img width="222px"  src="https://fs-ews.51h5.com/common/hw_220_black.png">
+        </a>
+      </td>
+      <td align="center"  valign="middle">
+        <a href="https://www.zto.com" target="_blank">
+          <img width="222px"  src="https://fscdn.zto.com/fs8/M02/B2/E4/wKhBD1-8o52Ae3GnAAASU3r62ME040.png">
+        </a>
+      </td>
     </tr>
     <tr></tr>
   </tbody>

cluster/cluster_impl/base_cluster_invoker.go

@@ -51,7 +51,7 @@ func newBaseClusterInvoker(directory cluster.Directory) baseClusterInvoker {
 	}
 }
 
-func (invoker *baseClusterInvoker) GetUrl() common.URL {
+func (invoker *baseClusterInvoker) GetUrl() *common.URL {
 	return invoker.directory.GetUrl()
 }
 

cluster/cluster_impl/failover_cluster_test.go

@@ -45,7 +45,7 @@ import (
 
 // nolint
 type MockInvoker struct {
-	url       common.URL
+	url       *common.URL
 	available bool
 	destroyed bool
 
@@ -53,7 +53,7 @@ type MockInvoker struct {
 }
 
 // nolint
-func NewMockInvoker(url common.URL, successCount int) *MockInvoker {
+func NewMockInvoker(url *common.URL, successCount int) *MockInvoker {
 	return &MockInvoker{
 		url:          url,
 		available:    true,
@@ -63,7 +63,7 @@ func NewMockInvoker(url common.URL, successCount int) *MockInvoker {
 }
 
 // nolint
-func (bi *MockInvoker) GetUrl() common.URL {
+func (bi *MockInvoker) GetUrl() *common.URL {
 	return bi.url
 }
 

cluster/directory/base_directory.go

@@ -65,8 +65,8 @@ func (dir *BaseDirectory) SetRouterChain(routerChain router.Chain) {
 }
 
 // GetUrl Get URL
-func (dir *BaseDirectory) GetUrl() common.URL {
-	return *dir.url
+func (dir *BaseDirectory) GetUrl() *common.URL {
+	return dir.url
 }
 
 // GetDirectoryUrl Get URL instance

cluster/directory/base_directory_test.go

@@ -40,19 +40,16 @@ var (
 )
 
 func TestNewBaseDirectory(t *testing.T) {
-	directory := NewBaseDirectory(&url)
-	assert.NotNil(t, directory)
-	assert.Equal(t, url, directory.GetUrl())
-	assert.Equal(t, &url, directory.GetDirectoryUrl())
+	dir := NewBaseDirectory(url)
+	assert.Equal(t, url, dir.GetUrl())
+	assert.Equal(t, url, dir.GetDirectoryUrl())
 }
 
 func TestBuildRouterChain(t *testing.T) {
 
 	regURL := url
 	regURL.AddParam(constant.INTERFACE_KEY, "mock-app")
-	directory := NewBaseDirectory(&regURL)
-
-	assert.NotNil(t, directory)
+	directory := NewBaseDirectory(regURL)
 
 	localIP := common.GetLocalIp()
 	rule := base64.URLEncoding.EncodeToString([]byte("true => " + " host = " + localIP))
@@ -66,18 +63,18 @@ func TestBuildRouterChain(t *testing.T) {
 	assert.NotNil(t, chain)
 }
 
-func getRouteURL(rule string, u common.URL) *common.URL {
+func getRouteURL(rule string, u *common.URL) *common.URL {
 	ru := u
 	ru.AddParam("rule", rule)
 	ru.AddParam("force", "true")
 	ru.AddParam(constant.ROUTER_KEY, "router")
-	return &ru
+	return ru
 }
 
 func TestIsProperRouter(t *testing.T) {
 	regURL := url
 	regURL.AddParam(constant.APPLICATION_KEY, "mock-app")
-	d := NewBaseDirectory(&regURL)
+	d := NewBaseDirectory(regURL)
 	localIP := common.GetLocalIp()
 	rule := base64.URLEncoding.EncodeToString([]byte("true => " + " host = " + localIP))
 	routeURL := getRouteURL(rule, anyURL)
@@ -87,7 +84,7 @@ func TestIsProperRouter(t *testing.T) {
 
 	regURL.AddParam(constant.APPLICATION_KEY, "")
 	regURL.AddParam(constant.INTERFACE_KEY, "com.foo.BarService")
-	d = NewBaseDirectory(&regURL)
+	d = NewBaseDirectory(regURL)
 	routeURL = getRouteURL(rule, anyURL)
 	routeURL.AddParam(constant.INTERFACE_KEY, "com.foo.BarService")
 	rst = d.isProperRouter(routeURL)
@@ -95,14 +92,14 @@ func TestIsProperRouter(t *testing.T) {
 
 	regURL.AddParam(constant.APPLICATION_KEY, "")
 	regURL.AddParam(constant.INTERFACE_KEY, "")
-	d = NewBaseDirectory(&regURL)
+	d = NewBaseDirectory(regURL)
 	routeURL = getRouteURL(rule, anyURL)
 	rst = d.isProperRouter(routeURL)
 	assert.True(t, rst)
 
 	regURL.SetParam(constant.APPLICATION_KEY, "")
 	regURL.SetParam(constant.INTERFACE_KEY, "")
-	d = NewBaseDirectory(&regURL)
+	d = NewBaseDirectory(regURL)
 	routeURL = getRouteURL(rule, anyURL)
 	routeURL.AddParam(constant.APPLICATION_KEY, "mock-service")
 	rst = d.isProperRouter(routeURL)
@@ -110,7 +107,7 @@ func TestIsProperRouter(t *testing.T) {
 
 	regURL.SetParam(constant.APPLICATION_KEY, "")
 	regURL.SetParam(constant.INTERFACE_KEY, "")
-	d = NewBaseDirectory(&regURL)
+	d = NewBaseDirectory(regURL)
 	routeURL = getRouteURL(rule, anyURL)
 	routeURL.AddParam(constant.INTERFACE_KEY, "mock-service")
 	rst = d.isProperRouter(routeURL)

cluster/directory/static_directory.go

@@ -34,13 +34,13 @@ type staticDirectory struct {
 
 // NewStaticDirectory Create a new staticDirectory with invokers
 func NewStaticDirectory(invokers []protocol.Invoker) *staticDirectory {
-	var url common.URL
+	var url *common.URL
 
 	if len(invokers) > 0 {
 		url = invokers[0].GetUrl()
 	}
 	dir := &staticDirectory{
-		BaseDirectory: NewBaseDirectory(&url),
+		BaseDirectory: NewBaseDirectory(url),
 		invokers:      invokers,
 	}
 
@@ -72,7 +72,7 @@ func (dir *staticDirectory) List(invocation protocol.Invocation) []protocol.Invo
 		return invokers
 	}
 	dirUrl := dir.GetUrl()
-	return routerChain.Route(&dirUrl, invocation)
+	return routerChain.Route(dirUrl, invocation)
 }
 
 // Destroy Destroy
@@ -91,7 +91,7 @@ func (dir *staticDirectory) BuildRouterChain(invokers []protocol.Invoker) error
 		return perrors.Errorf("invokers == null")
 	}
 	url := invokers[0].GetUrl()
-	routerChain, e := chain.NewRouterChain(&url)
+	routerChain, e := chain.NewRouterChain(url)
 	if e != nil {
 		return e
 	}

cluster/loadbalance/consistent_hash_test.go

@@ -84,9 +84,9 @@ func TestConsistentHashLoadBalanceSuite(t *testing.T) {
 
 type consistentHashLoadBalanceSuite struct {
 	suite.Suite
-	url1     common.URL
-	url2     common.URL
-	url3     common.URL
+	url1     *common.URL
+	url2     *common.URL
+	url3     *common.URL
 	invokers []protocol.Invoker
 	invoker1 protocol.Invoker
 	invoker2 protocol.Invoker

cluster/router/chain/chain.go

@@ -55,7 +55,7 @@ type RouterChain struct {
 
 	mutex sync.RWMutex
 
-	url common.URL
+	url *common.URL
 
 	// The times of address notification since last update for address cache
 	count int64
@@ -215,7 +215,7 @@ func (c *RouterChain) buildCache() {
 }
 
 // URL Return URL in RouterChain
-func (c *RouterChain) URL() common.URL {
+func (c *RouterChain) URL() *common.URL {
 	return c.url
 }
 
@@ -248,7 +248,7 @@ func NewRouterChain(url *common.URL) (*RouterChain, error) {
 		notify:         make(chan struct{}),
 	}
 	if url != nil {
-		chain.url = *url
+		chain.url = url
 	}
 
 	go chain.loop()

cluster/router/chain/chain_test.go

@@ -65,7 +65,6 @@ func TestNewRouterChain(t *testing.T) {
 	assert.NoError(t, err)
 	err = z.Create(path)
 	assert.NoError(t, err)
-
 	testyml := `scope: application
 key: mock-app
 enabled: true
@@ -81,7 +80,7 @@ conditions:
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	assert.Nil(t, err)
@@ -133,7 +132,7 @@ conditions:
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -159,7 +158,7 @@ func TestRouterChainRoute(t *testing.T) {
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -169,7 +168,7 @@ func TestRouterChainRoute(t *testing.T) {
 	url := getConditionRouteUrl(applicationKey)
 	assert.NotNil(t, url)
 
-	invokers := []protocol.Invoker{}
+	var invokers []protocol.Invoker
 	dubboURL, _ := common.NewURL(fmt.Sprintf(dubboForamt, test1234IP, port20000))
 	invokers = append(invokers, protocol.NewBaseInvoker(dubboURL))
 	chain.SetInvokers(invokers)
@@ -177,7 +176,7 @@ func TestRouterChainRoute(t *testing.T) {
 
 	targetURL, _ := common.NewURL(fmt.Sprintf(consumerFormat, test1111IP))
 	inv := &invocation.RPCInvocation{}
-	finalInvokers := chain.Route(&targetURL, inv)
+	finalInvokers := chain.Route(targetURL, inv)
 
 	assert.Equal(t, 1, len(finalInvokers))
 }
@@ -203,14 +202,14 @@ conditions:
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
 	assert.Nil(t, err)
 	assert.Equal(t, 2, len(chain.routers))
 
-	invokers := []protocol.Invoker{}
+	var invokers []protocol.Invoker
 	dubboURL, _ := common.NewURL(fmt.Sprintf(dubboForamt, test1234IP, port20000))
 	invokers = append(invokers, protocol.NewBaseInvoker(dubboURL))
 	chain.SetInvokers(invokers)
@@ -218,7 +217,7 @@ conditions:
 
 	targetURL, _ := common.NewURL(fmt.Sprintf(consumerFormat, test1111IP))
 	inv := &invocation.RPCInvocation{}
-	finalInvokers := chain.Route(&targetURL, inv)
+	finalInvokers := chain.Route(targetURL, inv)
 
 	assert.Equal(t, 0, len(finalInvokers))
 }
@@ -229,7 +228,7 @@ func TestRouterChainRouteNoRoute(t *testing.T) {
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	chain, err := NewRouterChain(getConditionNoRouteUrl(applicationKey))
@@ -239,7 +238,7 @@ func TestRouterChainRouteNoRoute(t *testing.T) {
 	url := getConditionRouteUrl(applicationKey)
 	assert.NotNil(t, url)
 
-	invokers := []protocol.Invoker{}
+	var invokers []protocol.Invoker
 	dubboURL, _ := common.NewURL(fmt.Sprintf(dubboForamt, test1234IP, port20000))
 	invokers = append(invokers, protocol.NewBaseInvoker(dubboURL))
 	chain.SetInvokers(invokers)
@@ -247,7 +246,7 @@ func TestRouterChainRouteNoRoute(t *testing.T) {
 
 	targetURL, _ := common.NewURL(fmt.Sprintf(consumerFormat, test1111IP))
 	inv := &invocation.RPCInvocation{}
-	finalInvokers := chain.Route(&targetURL, inv)
+	finalInvokers := chain.Route(targetURL, inv)
 
 	assert.Equal(t, 0, len(finalInvokers))
 }
@@ -258,7 +257,7 @@ func getConditionNoRouteUrl(applicationKey string) *common.URL {
 	url.AddParam(forceField, forceValue)
 	rule := base64.URLEncoding.EncodeToString([]byte("host = 1.1.1.1 => host != 1.2.3.4"))
 	url.AddParam(constant.RULE_KEY, rule)
-	return &url
+	return url
 }
 
 func getConditionRouteUrl(applicationKey string) *common.URL {
@@ -267,12 +266,12 @@ func getConditionRouteUrl(applicationKey string) *common.URL {
 	url.AddParam(forceField, forceValue)
 	rule := base64.URLEncoding.EncodeToString([]byte("host = 1.1.1.1 => host = 1.2.3.4"))
 	url.AddParam(constant.RULE_KEY, rule)
-	return &url
+	return url
 }
 
 func getRouteUrl(applicationKey string) *common.URL {
 	url, _ := common.NewURL(fmt.Sprintf(anyUrlFormat, test0000IP))
 	url.AddParam(applicationField, applicationKey)
 	url.AddParam(forceField, forceValue)
-	return &url
+	return url
 }

cluster/router/condition/app_router_test.go

@@ -71,7 +71,7 @@ conditions:
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	assert.Nil(t, err)
@@ -119,7 +119,7 @@ conditions:
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	assert.Nil(t, err)
@@ -158,7 +158,7 @@ conditions:
 	defer z.Close()
 
 	zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
-	configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(&zkUrl)
+	configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
 	config.GetEnvInstance().SetDynamicConfiguration(configuration)
 
 	assert.Nil(t, err)
@@ -194,5 +194,5 @@ func getAppRouteURL(applicationKey string) *common.URL {
 	url, _ := common.NewURL(fmt.Sprintf(conditionFormat, constant.ANYHOST_VALUE))
 	url.AddParam("application", applicationKey)
 	url.AddParam("force", "true")
-	return &url
+	return url
 }

cluster/router/condition/factory_test.go

@@ -52,13 +52,13 @@ const (
 )
 
 type MockInvoker struct {
-	url          common.URL
+	url          *common.URL
 	available    bool
 	destroyed    bool
 	successCount int
 }
 
-func NewMockInvoker(url common.URL, successCount int) *MockInvoker {
+func NewMockInvoker(url *common.URL, successCount int) *MockInvoker {
 	return &MockInvoker{
 		url:          url,
 		available:    true,
@@ -67,7 +67,7 @@ func NewMockInvoker(url common.URL, successCount int) *MockInvoker {
 	}
 }
 
-func (bi *MockInvoker) GetUrl() common.URL {
+func (bi *MockInvoker) GetUrl() *common.URL {
 	return bi.url
 }
 
@@ -75,20 +75,20 @@ func getRouteUrl(rule string) *common.URL {
 	url, _ := common.NewURL(fmt.Sprintf(factoryUrlFormat, constant.ANYHOST_VALUE))
 	url.AddParam("rule", rule)
 	url.AddParam("force", "true")
-	return &url
+	return url
 }
 
 func getRouteUrlWithForce(rule, force string) *common.URL {
 	url, _ := common.NewURL(fmt.Sprintf(factoryUrlFormat, constant.ANYHOST_VALUE))
 	url.AddParam("rule", rule)
 	url.AddParam("force", force)
-	return &url
+	return url
 }
 
 func getRouteUrlWithNoForce(rule string) *common.URL {
 	url, _ := common.NewURL(fmt.Sprintf(factoryUrlFormat, constant.ANYHOST_VALUE))
 	url.AddParam("rule", rule)
-	return &url
+	return url
 }
 
 func (bi *MockInvoker) IsAvailable() bool {
@@ -134,31 +134,31 @@ func TestRoute_matchWhen(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("=> host = 1.2.3.4"))
 	router, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
 	cUrl, _ := common.NewURL(fmt.Sprintf(factoryDubboFormat, factory1111Ip))
-	matchWhen := router.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen := router.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, true, matchWhen)
 	rule1 := base64.URLEncoding.EncodeToString([]byte("host = 2.2.2.2,1.1.1.1,3.3.3.3 => host = 1.2.3.4"))
 	router1, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule1))
-	matchWhen1 := router1.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen1 := router1.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, true, matchWhen1)
 	rule2 := base64.URLEncoding.EncodeToString([]byte("host = 2.2.2.2,1.1.1.1,3.3.3.3 & host !=1.1.1.1 => host = 1.2.3.4"))
 	router2, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule2))
-	matchWhen2 := router2.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen2 := router2.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, false, matchWhen2)
 	rule3 := base64.URLEncoding.EncodeToString([]byte("host !=4.4.4.4 & host = 2.2.2.2,1.1.1.1,3.3.3.3 => host = 1.2.3.4"))
 	router3, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule3))
-	matchWhen3 := router3.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen3 := router3.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, true, matchWhen3)
 	rule4 := base64.URLEncoding.EncodeToString([]byte("host !=4.4.4.* & host = 2.2.2.2,1.1.1.1,3.3.3.3 => host = 1.2.3.4"))
 	router4, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule4))
-	matchWhen4 := router4.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen4 := router4.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, true, matchWhen4)
 	rule5 := base64.URLEncoding.EncodeToString([]byte("host = 2.2.2.2,1.1.1.*,3.3.3.3 & host != 1.1.1.1 => host = 1.2.3.4"))
 	router5, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule5))
-	matchWhen5 := router5.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen5 := router5.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, false, matchWhen5)
 	rule6 := base64.URLEncoding.EncodeToString([]byte("host = 2.2.2.2,1.1.1.*,3.3.3.3 & host != 1.1.1.2 => host = 1.2.3.4"))
 	router6, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule6))
-	matchWhen6 := router6.(*ConditionRouter).MatchWhen(&cUrl, inv)
+	matchWhen6 := router6.(*ConditionRouter).MatchWhen(cUrl, inv)
 	assert.Equal(t, true, matchWhen6)
 }
 
@@ -182,12 +182,12 @@ func TestRoute_matchFilter(t *testing.T) {
 	router5, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule5))
 	router6, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule6))
 	cUrl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
-	ret1 := router1.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &cUrl, &invocation.RPCInvocation{})
-	ret2 := router2.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &cUrl, &invocation.RPCInvocation{})
-	ret3 := router3.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &cUrl, &invocation.RPCInvocation{})
-	ret4 := router4.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &cUrl, &invocation.RPCInvocation{})
-	ret5 := router5.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &cUrl, &invocation.RPCInvocation{})
-	ret6 := router6.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &cUrl, &invocation.RPCInvocation{})
+	ret1 := router1.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), cUrl, &invocation.RPCInvocation{})
+	ret2 := router2.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), cUrl, &invocation.RPCInvocation{})
+	ret3 := router3.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), cUrl, &invocation.RPCInvocation{})
+	ret4 := router4.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), cUrl, &invocation.RPCInvocation{})
+	ret5 := router5.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), cUrl, &invocation.RPCInvocation{})
+	ret6 := router6.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), cUrl, &invocation.RPCInvocation{})
 	assert.Equal(t, 1, len(ret1.ToArray()))
 	assert.Equal(t, 0, len(ret2.ToArray()))
 	assert.Equal(t, 0, len(ret3.ToArray()))
@@ -202,20 +202,20 @@ func TestRoute_methodRoute(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("host !=4.4.4.* & host = 2.2.2.2,1.1.1.1,3.3.3.3 => host = 1.2.3.4"))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
 	url, _ := common.NewURL("consumer://1.1.1.1/com.foo.BarService?methods=setFoo,getFoo,findFoo")
-	matchWhen := r.(*ConditionRouter).MatchWhen(&url, inv)
+	matchWhen := r.(*ConditionRouter).MatchWhen(url, inv)
 	assert.Equal(t, true, matchWhen)
 	url1, _ := common.NewURL(fmt.Sprintf(factoryConsumerMethodFormat, factory1111Ip))
-	matchWhen = r.(*ConditionRouter).MatchWhen(&url1, inv)
+	matchWhen = r.(*ConditionRouter).MatchWhen(url1, inv)
 	assert.Equal(t, true, matchWhen)
 	url2, _ := common.NewURL(fmt.Sprintf(factoryConsumerMethodFormat, factory1111Ip))
 	rule2 := base64.URLEncoding.EncodeToString([]byte("methods=getFoo & host!=1.1.1.1 => host = 1.2.3.4"))
 	router2, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule2))
-	matchWhen = router2.(*ConditionRouter).MatchWhen(&url2, inv)
+	matchWhen = router2.(*ConditionRouter).MatchWhen(url2, inv)
 	assert.Equal(t, false, matchWhen)
 	url3, _ := common.NewURL(fmt.Sprintf(factoryConsumerMethodFormat, factory1111Ip))
 	rule3 := base64.URLEncoding.EncodeToString([]byte("methods=getFoo & host=1.1.1.1 => host = 1.2.3.4"))
 	router3, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule3))
-	matchWhen = router3.(*ConditionRouter).MatchWhen(&url3, inv)
+	matchWhen = router3.(*ConditionRouter).MatchWhen(url3, inv)
 	assert.Equal(t, true, matchWhen)
 
 }
@@ -228,7 +228,7 @@ func TestRoute_ReturnFalse(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("host = " + localIP + " => false"))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 0, len(ret.ToArray()))
 }
 
@@ -240,7 +240,7 @@ func TestRoute_ReturnEmpty(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("host = " + localIP + " => "))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 0, len(ret.ToArray()))
 }
 
@@ -256,7 +256,7 @@ func TestRoute_ReturnAll(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("host = " + localIP + " => " + " host = " + localIP))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, len(invokers), len(ret.ToArray()))
 }
 
@@ -273,7 +273,7 @@ func TestRoute_HostFilter(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("host = " + localIP + " => " + " host = " + localIP))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 2, len(ret.ToArray()))
 	assert.Equal(t, invoker2, invokers[ret.ToArray()[0]])
 	assert.Equal(t, invoker3, invokers[ret.ToArray()[1]])
@@ -292,7 +292,7 @@ func TestRoute_Empty_HostFilter(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte(" => " + " host = " + localIP))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 2, len(ret.ToArray()))
 	assert.Equal(t, invoker2, invokers[ret.ToArray()[0]])
 	assert.Equal(t, invoker3, invokers[ret.ToArray()[1]])
@@ -311,7 +311,7 @@ func TestRoute_False_HostFilter(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("true => " + " host = " + localIP))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 2, len(ret.ToArray()))
 	assert.Equal(t, invoker2, invokers[ret.ToArray()[0]])
 	assert.Equal(t, invoker3, invokers[ret.ToArray()[1]])
@@ -330,7 +330,7 @@ func TestRoute_Placeholder(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte("host = " + localIP + " => " + " host = $host"))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrl(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 2, len(ret.ToArray()))
 	assert.Equal(t, invoker2, invokers[ret.ToArray()[0]])
 	assert.Equal(t, invoker3, invokers[ret.ToArray()[1]])
@@ -349,7 +349,7 @@ func TestRoute_NoForce(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte(fmt.Sprintf(factoryHostIp1234Format, localIP)))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrlWithNoForce(rule))
-	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	ret := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, len(invokers), len(ret.ToArray()))
 }
 
@@ -366,7 +366,7 @@ func TestRoute_Force(t *testing.T) {
 	rule := base64.URLEncoding.EncodeToString([]byte(fmt.Sprintf(factoryHostIp1234Format, localIP)))
 	curl, _ := common.NewURL(fmt.Sprintf(factoryConsumerFormat, localIP))
 	r, _ := newConditionRouterFactory().NewPriorityRouter(getRouteUrlWithForce(rule, "true"))
-	fileredInvokers := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), &curl, inv)
+	fileredInvokers := r.Route(utils.ToBitmap(invokers), setUpAddrCache(invokers), curl, inv)
 	assert.Equal(t, 0, len(fileredInvokers.ToArray()))
 }
 

cluster/router/condition/file.go

@@ -39,7 +39,7 @@ import (
 type FileConditionRouter struct {
 	listenableRouter
 	parseOnce sync.Once
-	url       common.URL
+	url       *common.URL
 }
 
 // NewFileConditionRouter Create file condition router instance with content ( from config file)
@@ -60,11 +60,11 @@ func NewFileConditionRouter(content []byte) (*FileConditionRouter, error) {
 }
 
 // URL Return URL in file condition router n
-func (f *FileConditionRouter) URL() common.URL {
+func (f *FileConditionRouter) URL() *common.URL {
 	f.parseOnce.Do(func() {
 		routerRule := f.routerRule
 		rule := parseCondition(routerRule.Conditions)
-		f.url = *common.NewURLWithOptions(
+		f.url = common.NewURLWithOptions(
 			common.WithProtocol(constant.CONDITION_ROUTE_PROTOCOL),
 			common.WithIp(constant.ANYHOST_VALUE),
 			common.WithParams(url.Values{}),

cluster/router/condition/listenable_router.go

@@ -148,6 +148,6 @@ func (l *listenableRouter) Priority() int64 {
 }
 
 // URL Return URL in listenable router
-func (l *listenableRouter) URL() common.URL {
-	return *l.url
+func (l *listenableRouter) URL() *common.URL {
+	return l.url
 }

cluster/router/condition/router.go

@@ -138,8 +138,8 @@ func (c *ConditionRouter) Priority() int64 {
 }
 
 // URL Return URL in condition router
-func (c *ConditionRouter) URL() common.URL {
-	return *c.url
+func (c *ConditionRouter) URL() *common.URL {
+	return c.url
 }
 
 // Enabled Return is condition router is enabled
@@ -173,7 +173,7 @@ func (c *ConditionRouter) Route(invokers *roaring.Bitmap, cache router.Cache, ur
 		index := iter.Next()
 		invoker := cache.GetInvokers()[index]
 		invokerUrl := invoker.GetUrl()
-		isMatchThen := c.MatchThen(&invokerUrl, url)
+		isMatchThen := c.MatchThen(invokerUrl, url)
 		if isMatchThen {
 			result.Add(index)
 		}

cluster/router/condition/router_rule_test.go

@@ -80,5 +80,5 @@ conditions:
 
 func TestIsMatchGlobPattern(t *testing.T) {
 	url, _ := common.NewURL("dubbo://localhost:8080/Foo?key=v*e")
-	assert.Equal(t, true, isMatchGlobalPattern("$key", "value", &url))
+	assert.Equal(t, true, isMatchGlobalPattern("$key", "value", url))
 }

cluster/router/condition/router_test.go

@@ -59,7 +59,7 @@ func TestParseRule(t *testing.T) {
 
 func TestNewConditionRouter(t *testing.T) {
 	url, _ := common.NewURL(`condition://0.0.0.0:?application=mock-app&category=routers&force=true&priority=1&router=condition&rule=YSAmIGMgPT4gYiAmIGQ%3D`)
-	router, err := NewConditionRouter(&url)
+	router, err := NewConditionRouter(url)
 	assert.Nil(t, err)
 	assert.Equal(t, true, router.Enabled())
 	assert.Equal(t, true, router.Force)
@@ -73,16 +73,16 @@ func TestNewConditionRouter(t *testing.T) {
 	assert.Error(t, err)
 
 	url, _ = common.NewURL(`condition://0.0.0.0:?application=mock-app&category=routers&force=true&priority=1&router=condition&rule=YSAmT4gYiAmIGQ%3D`)
-	router, err = NewConditionRouter(&url)
+	router, err = NewConditionRouter(url)
 	assert.Error(t, err)
 
 	url, _ = common.NewURL(`condition://0.0.0.0:?application=mock-app&category=routers&force=true&router=condition&rule=YSAmIGMgPT4gYiAmIGQ%3D`)
-	router, err = NewConditionRouter(&url)
+	router, err = NewConditionRouter(url)
 	assert.Nil(t, err)
 	assert.Equal(t, int64(150), router.Priority())
 
 	url, _ = common.NewURL(`condition://0.0.0.0:?category=routers&force=true&interface=mock-service&router=condition&rule=YSAmIGMgPT4gYiAmIGQ%3D`)
-	router, err = NewConditionRouter(&url)
+	router, err = NewConditionRouter(url)
 	assert.Nil(t, err)
 	assert.Equal(t, int64(140), router.Priority())
 }

cluster/router/healthcheck/default_health_check_test.go

@@ -43,7 +43,7 @@ const (
 func TestDefaultHealthCheckerIsHealthy(t *testing.T) {
 	defer protocol.CleanAllStatus()
 	url, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1010IP))
-	hc := NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	hc := NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	invoker := NewMockInvoker(url)
 	healthy := hc.IsHealthy(invoker)
 	assert.True(t, healthy)
@@ -54,7 +54,7 @@ func TestDefaultHealthCheckerIsHealthy(t *testing.T) {
 	for i := 0; i < 11; i++ {
 		request(url, healthCheckMethodTest, 0, true, false)
 	}
-	hc = NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	hc = NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	healthy = hc.IsHealthy(invoker)
 	// the outgoing request is more than OUTSTANDING_REQUEST_COUNT_LIMIT, go to unhealthy
 	assert.False(t, hc.IsHealthy(invoker))
@@ -65,7 +65,7 @@ func TestDefaultHealthCheckerIsHealthy(t *testing.T) {
 	}
 	url.SetParam(constant.SUCCESSIVE_FAILED_REQUEST_THRESHOLD_KEY, "10")
 	url.SetParam(constant.OUTSTANDING_REQUEST_COUNT_LIMIT_KEY, "1000")
-	hc = NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	hc = NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	healthy = hc.IsHealthy(invoker)
 	assert.False(t, hc.IsHealthy(invoker))
 
@@ -78,7 +78,7 @@ func TestDefaultHealthCheckerIsHealthy(t *testing.T) {
 func TestDefaultHealthCheckerGetCircuitBreakerSleepWindowTime(t *testing.T) {
 	defer protocol.CleanAllStatus()
 	url, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1010IP))
-	defaultHc := NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	defaultHc := NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	// Increase the number of failed requests
 	for i := 0; i < 100; i++ {
 		request(url, healthCheckMethodTest, 1, false, false)
@@ -88,7 +88,7 @@ func TestDefaultHealthCheckerGetCircuitBreakerSleepWindowTime(t *testing.T) {
 
 	// Adjust the threshold size to 1000
 	url.SetParam(constant.SUCCESSIVE_FAILED_REQUEST_THRESHOLD_KEY, "1000")
-	sleepWindowTime = NewDefaultHealthChecker(&url).(*DefaultHealthChecker).getCircuitBreakerSleepWindowTime(protocol.GetURLStatus(url))
+	sleepWindowTime = NewDefaultHealthChecker(url).(*DefaultHealthChecker).getCircuitBreakerSleepWindowTime(protocol.GetURLStatus(url))
 	assert.True(t, sleepWindowTime == 0)
 
 	url1, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1011IP))
@@ -107,7 +107,7 @@ func TestDefaultHealthCheckerGetCircuitBreakerSleepWindowTime(t *testing.T) {
 func TestDefaultHealthCheckerGetCircuitBreakerTimeout(t *testing.T) {
 	defer protocol.CleanAllStatus()
 	url, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1010IP))
-	defaultHc := NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	defaultHc := NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	timeout := defaultHc.getCircuitBreakerTimeout(protocol.GetURLStatus(url))
 	assert.True(t, timeout == 0)
 	url1, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1011IP))
@@ -126,7 +126,7 @@ func TestDefaultHealthCheckerGetCircuitBreakerTimeout(t *testing.T) {
 func TestDefaultHealthCheckerIsCircuitBreakerTripped(t *testing.T) {
 	defer protocol.CleanAllStatus()
 	url, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1010IP))
-	defaultHc := NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	defaultHc := NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	status := protocol.GetURLStatus(url)
 	tripped := defaultHc.isCircuitBreakerTripped(status)
 	assert.False(t, tripped)
@@ -142,7 +142,7 @@ func TestDefaultHealthCheckerIsCircuitBreakerTripped(t *testing.T) {
 func TestNewDefaultHealthChecker(t *testing.T) {
 	defer protocol.CleanAllStatus()
 	url, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1010IP))
-	defaultHc := NewDefaultHealthChecker(&url).(*DefaultHealthChecker)
+	defaultHc := NewDefaultHealthChecker(url).(*DefaultHealthChecker)
 	assert.NotNil(t, defaultHc)
 	assert.Equal(t, defaultHc.outStandingRequestConutLimit, int32(math.MaxInt32))
 	assert.Equal(t, defaultHc.requestSuccessiveFailureThreshold, int32(constant.DEFAULT_SUCCESSIVE_FAILED_REQUEST_MAX_DIFF))
@@ -150,13 +150,13 @@ func TestNewDefaultHealthChecker(t *testing.T) {
 	url1, _ := common.NewURL(fmt.Sprintf(healthCheckDubboUrlFormat, healthCheckDubbo1010IP))
 	url1.SetParam(constant.OUTSTANDING_REQUEST_COUNT_LIMIT_KEY, "10")
 	url1.SetParam(constant.SUCCESSIVE_FAILED_REQUEST_THRESHOLD_KEY, "10")
-	nondefaultHc := NewDefaultHealthChecker(&url1).(*DefaultHealthChecker)
+	nondefaultHc := NewDefaultHealthChecker(url1).(*DefaultHealthChecker)
 	assert.NotNil(t, nondefaultHc)
 	assert.Equal(t, nondefaultHc.outStandingRequestConutLimit, int32(10))
 	assert.Equal(t, nondefaultHc.requestSuccessiveFailureThreshold, int32(10))
 }
 
-func request(url common.URL, method string, elapsed int64, active, succeeded bool) {
+func request(url *common.URL, method string, elapsed int64, active, succeeded bool) {
 	protocol.BeginCount(url, method)
 	if !active {
 		protocol.EndCount(url, method, elapsed, succeeded)

cluster/router/healthcheck/factory_test.go

@@ -33,18 +33,18 @@ import (
 
 // nolint
 type MockInvoker struct {
-	url common.URL
+	url *common.URL
 }
 
 // nolint
-func NewMockInvoker(url common.URL) *MockInvoker {
+func NewMockInvoker(url *common.URL) *MockInvoker {
 	return &MockInvoker{
 		url: url,
 	}
 }
 
 // nolint
-func (bi *MockInvoker) GetUrl() common.URL {
+func (bi *MockInvoker) GetUrl() *common.URL {
 	return bi.url
 }
 

cluster/router/healthcheck/health_check_route.go

@@ -106,8 +106,8 @@ func (r *HealthCheckRouter) Priority() int64 {
 }
 
 // URL Return URL in router
-func (r *HealthCheckRouter) URL() common.URL {
-	return *r.url
+func (r *HealthCheckRouter) URL() *common.URL {
+	return r.url
 }
 
 // HealthyChecker returns the HealthChecker bound to this HealthCheckRouter