Netflix Archaius

Instead of implementing configuration interfaces manually, you can use ConfigProxyFactory to create a Java Proxy bound to your configuration. This decouples your business logic from the configuration implementation and ensures configuration is fully loaded and available during constructor injection.

1. Define an interface with @Configuration(prefix="...").
2. Use proxyFactory.newProxy(YourInterface.class) in a Guice @Provides method.

@Configuration(prefix="foo")
interface FooConfiguration {
   int getTimeout();     // maps to "foo.timeout"
   String getName();     // maps to "foo.name"
}

// In your Guice Module
public class FooModule extends AbstractModule {
    @Provides
    FooConfiguration getFooConfiguration(ConfigProxyFactory proxyFactory) {
        proxyFactory.newProxy(FooConfiguration.class);
    }
}

// Usage
@Singleton
public class Foo {
    @Inject
    public Foo(FooConfiguration config) {
        // config is ready to use
    }
}

You can also override the prefix by passing it as a second argument to newProxy:

proxyFactory.newProxy(FooConfiguration.class, "otherprefix.foo");

You can load configuration into the @LibrariesLayer by annotating an injectable class with @ConfigurationSource.

Important: @ConfigurationSource processing occurs after the constructor is called. Therefore, you cannot rely on the configuration being available inside the constructor of the annotated class. It is recommended to inject a separate configuration class into your functional code instead of mixing them.

// The configuration holder
@Singleton
@ConfigurationSource({"serviceA"})
public class ServiceAConfiguration {
    // properties will be loaded here
}

// The functional class
@Singleton
public class ServiceA {
    @Inject
    public ServiceA(ServiceAConfiguration config) {
        config.getTimeout(); // Returns the loaded value
    }
}

// Class where configuration is loaded
@Singleton
@ConfigurationSource({"serviceA"})
public class ServiceAConfiguration {
}

// Class where configuration is used
@Singleton
public class ServiceA {
    @Inject
    public ServiceA(ServiceAConfiguration config) {
        config.getTimeout();  // Will return the loaded configuration value
    }
}

For properties expected to change at runtime, use the Property API instead of calling Config directly. Property objects optimize the caching of resolved values from the configuration hierarchy, making them much more efficient for frequent access.

1. Create a Property Factory

Use DefaultPropertyFactory.from(config) to create a factory based on your existing configuration.

2. Create a Property

Use the factory to define a typed property with a default value.

3. Access the Value

Call .get() on the property object to retrieve the most recent cached value.

4. React to Changes

Register a com.netflix.archaius.api.PropertyListener to execute logic whenever a property value changes.

// Create a fast property factory using any Config as the source
DefaultPropertyFactory factory = DefaultPropertyFactory.from(config);

// Create a Property<Integer> object
Property<Integer> timeout = factory.getProperty("server.timeout").asInteger(DEFAULT_TIMEOUT_VALUE);

// Access the cached property value
Thread.sleep(timeout.get());

// React to property change notification
Property<Integer> timeout = factory
    .getProperty("server.timeout")
    .asInteger() 
    .addListener(new PropertyListener<Integer>() {
        public void onChange(Integer value) {
            socket.setReadTimeout(value);
        }
        
        public void onError(Throwable error) {
        }
    });

The AbstractConfigurationBridge class (part of the archaius2-archaius1-bridge module) allows you to use Archaius 1.x Configuration objects within an Archaius 2.x environment. It implements Apache Commons Configuration interfaces (AbstractConfiguration, AggregatedConfiguration) while wrapping an Archaius 2.x Config instance.

Key capabilities include:

• Property Access: Access properties from the bridged Archaius 2.x Config using standard Apache Commons methods like getString(key, defaultValue) or containsKey(key).
• Configuration Management: Add or remove named configurations via addConfiguration(AbstractConfiguration config, String name) and removeConfiguration(String name).
• Dynamic Updates: The bridge listens to Archaius 2.x configuration changes and triggers corresponding Apache Commons PropertyListener events.
• Property Resolution: Use resolve(String value) to perform interpolation/resolution using the underlying Archaius 2.x configuration logic.