[feat] 1. 优化了DefaultNamespace的使用体验，注释和测试用例

Author: liuxingwang

agollo.go

@@ -229,14 +229,7 @@ func (a *agollo) reloadNamespace(namespace string) (status int, conf Configurati
 }
 
 func (a *agollo) Get(key string, opts ...GetOption) string {
-	getOpts := newGetOptions(
-		append(
-			[]GetOption{
-				WithNamespace(a.opts.DefaultNamespace),
-			},
-			opts...,
-		)...,
-	)
+	getOpts := a.opts.newGetOptions(opts...)
 
 	val, found := a.GetNameSpace(getOpts.Namespace)[key]
 	if !found {

options.go

@@ -16,27 +16,26 @@ var (
 )
 
 type Options struct {
-	AppID                      string        // appid
-	Cluster                    string        // 默认的集群名称，默认：default
-	DefaultNamespace           string        // 默认的命名空间，默认：application
-	PreloadNamespaces          []string      // 预加载命名空间，默认：application
-	ApolloClient               ApolloClient  // apollo HTTP api实现
-	Logger                     Logger        // 需要日志需要设置实现，或者注入有效的io.Writer，默认: ioutil.Discard
-	AutoFetchOnCacheMiss       bool          // 自动获取非预设以外的namespace的配置，默认：false
-	LongPollerInterval         time.Duration // 轮训间隔时间，默认：1s
-	BackupFile                 string        // 备份文件存放地址，默认：.agollo
-	FailTolerantOnBackupExists bool          // 服务器连接失败时允许读取备份，默认：false
-	Balancer                   Balancer      // ConfigServer负载均衡
-	EnableSLB                  bool          // 启用ConfigServer负载均衡
-	RefreshIntervalInSecond    time.Duration // ConfigServer刷新间隔
-	ClientOptions              []ApolloClientOption
+	AppID                      string               // appid
+	Cluster                    string               // 默认的集群名称，默认：default
+	DefaultNamespace           string               // Get时默认使用的命名空间，如果设置了该值，而不在PreloadNamespaces中，默认也会加入初始化逻辑中
+	PreloadNamespaces          []string             // 预加载命名空间，默认：为空
+	ApolloClient               ApolloClient         // apollo HTTP api实现
+	Logger                     Logger               // 日志实现类，可以设置自定义实现或者通过NewLogger()创建并设置有效的io.Writer，默认: ioutil.Discard
+	AutoFetchOnCacheMiss       bool                 // 自动获取非预设以外的Namespace的配置，默认：false
+	LongPollerInterval         time.Duration        // 轮训间隔时间，默认：1s
+	BackupFile                 string               // 备份文件存放地址，默认：.agollo
+	FailTolerantOnBackupExists bool                 // 服务器连接失败时允许读取备份，默认：false
+	Balancer                   Balancer             // ConfigServer负载均衡
+	EnableSLB                  bool                 // 启用ConfigServer负载均衡
+	RefreshIntervalInSecond    time.Duration        // ConfigServer刷新间隔
+	ClientOptions              []ApolloClientOption // 设置apollo HTTP api的配置项
 }
 
 func newOptions(configServerURL, appID string, opts ...Option) (Options, error) {
 	var options = Options{
 		AppID:                      appID,
 		Cluster:                    defaultCluster,
-		DefaultNamespace:           defaultNamespace,
 		ApolloClient:               NewApolloClient(),
 		Logger:                     NewLogger(),
 		AutoFetchOnCacheMiss:       defaultAutoFetchOnCacheMiss,
@@ -68,6 +67,13 @@ func newOptions(configServerURL, appID string, opts ...Option) (Options, error)
 		options.Balancer = b
 	}
 
+	if options.DefaultNamespace != "" &&
+		!stringInSlice(options.DefaultNamespace, options.PreloadNamespaces) {
+
+		options.PreloadNamespaces = append(
+			options.PreloadNamespaces, options.DefaultNamespace)
+	}
+
 	return options, nil
 }
 
@@ -177,22 +183,31 @@ func AccessKey(accessKey string) Option {
 	}
 }
 
-func WithClientOptinons(opts ...ApolloClientOption) Option {
+func WithClientOptions(opts ...ApolloClientOption) Option {
 	return func(o *Options) {
 		o.ClientOptions = append(o.ClientOptions, opts...)
 	}
 }
 
 type GetOptions struct {
+	// Get时，如果key不存在将返回此值
 	DefaultValue string
-	Namespace    string
+
+	// Get时，显示的指定需要获取那个Namespace中的key。非空情况下，优先级顺序为：
+	// GetOptions.Namespace > Options.DefaultNamespace > "application"
+	Namespace string
 }
 
-func newGetOptions(opts ...GetOption) GetOptions {
+func (o Options) newGetOptions(opts ...GetOption) GetOptions {
 	var getOpts GetOptions
 	for _, opt := range opts {
 		opt(&getOpts)
 	}
+
+	if getOpts.Namespace == "" {
+		getOpts.Namespace = nonEmptyString(defaultNamespace, o.DefaultNamespace)
+	}
+
 	return getOpts
 }
 

options_test.go

@@ -0,0 +1,101 @@
+package agollo
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOptions(t *testing.T) {
+	var (
+		configServerURL = "localhost:8080"
+		appID           = "SampleApp"
+	)
+	var tests = []struct {
+		Options []Option
+		Check   func(Options)
+	}{
+		{
+			[]Option{},
+			func(opts Options) {
+				assert.Equal(t, appID, opts.AppID)
+				assert.Equal(t, defaultCluster, opts.Cluster)
+				assert.Equal(t, defaultAutoFetchOnCacheMiss, opts.AutoFetchOnCacheMiss)
+				assert.Equal(t, defaultLongPollInterval, opts.LongPollerInterval)
+				assert.Equal(t, defaultBackupFile, opts.BackupFile)
+				assert.Equal(t, defaultFailTolerantOnBackupExists, opts.FailTolerantOnBackupExists)
+				assert.Equal(t, defaultEnableSLB, opts.EnableSLB)
+				assert.NotNil(t, opts.Logger)
+				assert.NotNil(t, opts.ApolloClient)
+				assert.NotNil(t, opts.Balancer)
+				assert.Empty(t, opts.PreloadNamespaces)
+				assert.Empty(t, opts.DefaultNamespace)
+				getOpts := opts.newGetOptions()
+				assert.Equal(t, "application", getOpts.Namespace)
+				getOpts = opts.newGetOptions(WithNamespace("customize_namespace"))
+				assert.Equal(t, "customize_namespace", getOpts.Namespace)
+				ac := &apolloClient{}
+				ac.Apply(opts.ClientOptions...)
+				assert.Empty(t, ac.AccessKey)
+			},
+		},
+		{
+			[]Option{
+				Cluster("test_cluster"),
+				DefaultNamespace("default_namespace"),
+				PreloadNamespaces("preload_namespace"),
+				AutoFetchOnCacheMiss(),
+				LongPollerInterval(time.Second * 30),
+				BackupFile("test_backup"),
+				FailTolerantOnBackupExists(),
+				AccessKey("test_access_key"),
+			},
+			func(opts Options) {
+				assert.Equal(t, "test_cluster", opts.Cluster)
+				assert.Equal(t, []string{"preload_namespace", "default_namespace"}, opts.PreloadNamespaces)
+				assert.Equal(t, "default_namespace", opts.DefaultNamespace)
+				getOpts := opts.newGetOptions()
+				assert.Equal(t, "default_namespace", getOpts.Namespace)
+				getOpts = opts.newGetOptions(WithNamespace("customize_namespace"))
+				assert.Equal(t, "customize_namespace", getOpts.Namespace)
+				assert.Equal(t, true, opts.AutoFetchOnCacheMiss)
+				assert.Equal(t, time.Second*30, opts.LongPollerInterval)
+				assert.Equal(t, "test_backup", opts.BackupFile)
+				assert.Equal(t, true, opts.FailTolerantOnBackupExists)
+				ac := &apolloClient{}
+				ac.Apply(opts.ClientOptions...)
+				assert.Equal(t, "test_access_key", ac.AccessKey)
+			},
+		},
+		{
+			[]Option{
+				EnableSLB(true),
+				WithApolloClient(&mockApolloClient{
+					getConfigServers: func(metaServerURL, appID string) (i int, servers []ConfigServer, err error) {
+						return 200,
+							[]ConfigServer{
+								ConfigServer{
+									AppName:     "test",
+									InstanceID:  "test",
+									HomePageURL: "http://localhost:8080",
+								},
+							},
+							nil
+					},
+				}),
+			},
+			func(opts Options) {
+				assert.Equal(t, true, opts.EnableSLB)
+			},
+		},
+	}
+
+	for _, test := range tests {
+		opts, err := newOptions(configServerURL, appID, test.Options...)
+		if err != nil {
+			assert.Nil(t, err)
+		}
+		test.Check(opts)
+	}
+}

util.go

@@ -18,3 +18,21 @@ func splitCommaSeparatedURL(s string) []string {
 
 	return urls
 }
+
+func stringInSlice(t string, ss []string) bool {
+	for _, s := range ss {
+		if s == t {
+			return true
+		}
+	}
+	return false
+}
+
+func nonEmptyString(def string, ss ...string) string {
+	for _, s := range ss {
+		if s != "" {
+			return s
+		}
+	}
+	return def
+}