agollo

To start using Agollo, you must define an AppConfig and initialize the client using agollo.StartWithConfig.

AppConfig requires the following fields:

• AppID: The unique identifier for your application.
• Cluster: The deployment cluster (e.g., dev).
• IP: The Apollo server address (e.g., http://localhost:8080).
• NamespaceName: The specific namespace to monitor.
• IsBackupConfig: A boolean indicating if fallback configuration should be used.
• Secret: The access key/secret for configuration access.

agollo.StartWithConfig takes a provider function that returns your *config.AppConfig and an error.

package main

import (
	"fmt"

	"github.com/apolloconfig/agollo/v5"
	"github.com/apolloconfig/agollo/v5/env/config"
)

func main() {
	c := &config.AppConfig{
		AppID:          "testApplication_yang",
		Cluster:        "dev",
		IP:             "http://localhost:8080",
		NamespaceName:  "dubbo",
		IsBackupConfig: true,
		Secret:         "6ce3ff7e96a24335a9634fe9abca6d51",
	}

	client, _ := agollo.StartWithConfig(func() (*config.AppConfig, error) {
		return c, nil
	})
	fmt.Println("Apollo configuration initialized successfully")

	// Use your apollo key to test
	cache := client.GetConfigCache(c.NamespaceName)
	value, _ := cache.Get("key")
	fmt.Println(value)
}

You can start the Agollo client in two ways: using default file configurations or providing a custom configuration function.

Option 1: Default Configuration

Use Start() to initialize the client using the default configuration files recognized by the library.

Option 2: Custom Configuration

Use StartWithConfig(loadAppConfig func() (*config.AppConfig, error)) to provide a custom function that returns an *config.AppConfig. This is useful if you need to load configuration from a non-standard source or perform custom logic during initialization.

If MustStart is set to true in your configuration and no configuration is read during startup, StartWithConfig will return an error.

package main

import (
	"github.com/apolloconfig/agollo/v5"
	"github.com/apolloconfig/agollo/v5/env/config"
)

func main() {
	// Custom configuration approach
	client, err := agollo.StartWithConfig(func() (*config.AppConfig, error) {
		// Return your custom AppConfig here
		return &config.AppConfig{
			// ... configuration fields
		}, nil
	})
	if err != nil {
		panic(err)
	}
	defer client.Close()

	// Use the client...
}

The Client interface provides several methods to retrieve configuration values from the default namespace. These methods handle type conversion and allow for default values if a key is missing.

Available Value Methods

• GetValue(key string) string: Returns the value as a string.
• GetStringValue(key string, defaultValue string) string: Returns the string value or the provided default.
• GetIntValue(key string, defaultValue int) int: Returns the integer value or the provided default.
• GetFloatValue(key string, defaultValue float64) float64: Returns the float value or the provided default.
• GetBoolValue(key string, defaultValue bool) bool: Returns the boolean value or the provided default.
• GetStringSliceValue(key string, defaultValue []string) []string: Returns a slice of strings (delimited by ,).
• GetIntSliceValue(key string, defaultValue []int) []int: Returns a slice of integers (delimited by ,).

Note: All these methods target the default namespace. To target a specific namespace, use GetConfig(namespace string).

// Example of retrieving various types from the default namespace
valStr := client.GetStringValue("app.name", "default-app")
valInt := client.GetIntValue("app.port", 8080)
valBool := client.GetBoolValue("app.debug", false)
valSlice := client.GetStringSliceValue("app.tags", []string{"prod"})

Agollo allows you to react to configuration updates by adding a ChangeListener.

Registering a Listener

Use AddChangeListener(listener storage.ChangeListener) to register a new listener. When a configuration in a namespace changes, the listener will be notified.

Removing a Listener

Use RemoveChangeListener(listener storage.ChangeListener) to stop receiving updates for a specific listener.

Event Dispatching

If you want to enable event dispatching for specific keys, call UseEventDispatch(). This adds a specialized listener that can be used to trigger application-level events when specific configuration keys change.

// Define a listener
listener := myCustomListener

// Add it to the client
client.AddChangeListener(listener)

// Optionally enable event dispatching
client.UseEventDispatch()

// Remember to clean up if necessary
client.RemoveChangeListener(listener)