聊聊dubbo-go的apolloConfiguration

const (
    apolloProtocolPrefix = "http://"
    apolloConfigFormat   = "%s.%s"
)

type apolloConfiguration struct {
    url *common.URL

    listeners sync.Map
    appConf   *agollo.AppConfig
    parser    parser.ConfigurationParser
}

func newApolloConfiguration(url *common.URL) (*apolloConfiguration, error) {
    c := &apolloConfiguration{
        url: url,
    }
    configAddr := c.getAddressWithProtocolPrefix(url)
    configCluster := url.GetParam(constant.CONFIG_CLUSTER_KEY, "")

    appId := url.GetParam(constant.CONFIG_APP_ID_KEY, "")
    namespaces := getProperties(url.GetParam(constant.CONFIG_NAMESPACE_KEY, cc.DEFAULT_GROUP))
    c.appConf = &agollo.AppConfig{
        AppId:         appId,
        Cluster:       configCluster,
        NamespaceName: namespaces,
        Ip:            configAddr,
    }

    agollo.InitCustomConfig(func() (*agollo.AppConfig, error) {
        return c.appConf, nil
    })

    return c, agollo.Start()
}

func (c *apolloConfiguration) GetProperties(key string, opts ...cc.Option) (string, error) {
    /**
     * when group is not null, we are getting startup configs(config file) from Config Center, for example:
     * key=dubbo.propertie
     */
    config := agollo.GetConfig(key)
    if config == nil {
        return "", errors.New(fmt.Sprintf("nothing in namespace:%s ", key))
    }
    return config.GetContent(agollo.Properties), nil
}

func (c *apolloConfiguration) AddListener(key string, listener cc.ConfigurationListener, opts ...cc.Option) {
    k := &cc.Options{}
    for _, opt := range opts {
        opt(k)
    }

    key = k.Group + key
    l, _ := c.listeners.LoadOrStore(key, NewApolloListener())
    l.(*apolloListener).AddListener(listener)
}

func (c *apolloConfiguration) RemoveListener(key string, listener cc.ConfigurationListener, opts ...cc.Option) {
    k := &cc.Options{}
    for _, opt := range opts {
        opt(k)
    }

    key = k.Group + key
    l, ok := c.listeners.Load(key)
    if ok {
        l.(*apolloListener).RemoveListener(listener)
    }
}

type apolloListener struct {
    listeners map[config_center.ConfigurationListener]struct{}
}

// NewApolloListener ...
func NewApolloListener() *apolloListener {
    return &apolloListener{
        listeners: make(map[config_center.ConfigurationListener]struct{}, 0),
    }
}

// OnChange ...
func (a *apolloListener) OnChange(changeEvent *agollo.ChangeEvent) {
    for key, change := range changeEvent.Changes {
        for listener := range a.listeners {
            listener.Process(&config_center.ConfigChangeEvent{
                ConfigType: getChangeType(change.ChangeType),
                Key:        key,
                Value:      change.NewValue,
            })
        }
    }
}