Configuration Management

package io.dropwizard.configuration;

public class ConfigurationFactory<T> {
    /**
     * Builds a configuration object from the given source.
     */
    public T build(ConfigurationSourceProvider provider, String path) 
           throws IOException, ConfigurationException;
    
    /**
     * Builds a configuration object from a file.
     */
    public T build(File file) throws IOException, ConfigurationException;
    
    /**
     * Builds a configuration object from an input stream.
     */
    public T build(InputStream input) throws IOException, ConfigurationException;
    
    /**
     * Creates a new configuration factory.
     */
    public static <T> ConfigurationFactory<T> forClass(Class<T> klass,
                                                       Validator validator,
                                                       ObjectMapper objectMapper,
                                                       String propertyPrefix);
}

package io.dropwizard.configuration;

public interface ConfigurationSourceProvider {
    /**
     * Opens an InputStream for the given path.
     */
    InputStream open(String path) throws IOException;
}

public class FileConfigurationSourceProvider implements ConfigurationSourceProvider {
    @Override
    public InputStream open(String path) throws IOException;
}

public class ResourceConfigurationSourceProvider implements ConfigurationSourceProvider {
    @Override
    public InputStream open(String path) throws IOException;
}

public class UrlConfigurationSourceProvider implements ConfigurationSourceProvider {
    @Override
    public InputStream open(String path) throws IOException;
}

@Override
public void initialize(Bootstrap<MyConfiguration> bootstrap) {
    // Load configuration from classpath
    bootstrap.setConfigurationSourceProvider(new ResourceConfigurationSourceProvider());
    
    // Load configuration from URLs
    bootstrap.setConfigurationSourceProvider(new UrlConfigurationSourceProvider());
}

package io.dropwizard.configuration;

public class SubstitutingSourceProvider implements ConfigurationSourceProvider {
    /**
     * Creates a substituting source provider with the given underlying provider and substitutor.
     */
    public SubstitutingSourceProvider(ConfigurationSourceProvider provider,
                                     StringSubstitutor substitutor);
}

public class EnvironmentVariableSubstitutor extends StringSubstitutor {
    /**
     * Creates a substitutor that replaces environment variables.
     * @param strict if true, throws exception for undefined variables
     */
    public EnvironmentVariableSubstitutor(boolean strict);
}

@Override
public void initialize(Bootstrap<MyConfiguration> bootstrap) {
    // Enable environment variable substitution
    bootstrap.setConfigurationSourceProvider(
        new SubstitutingSourceProvider(
            bootstrap.getConfigurationSourceProvider(),
            new EnvironmentVariableSubstitutor(false)
        )
    );
}

# config.yml
database:
  url: ${DATABASE_URL:-jdbc:h2:mem:test}
  username: ${DB_USERNAME:-sa}
  password: ${DB_PASSWORD:-}

server:
  applicationConnectors:
    - type: http
      port: ${PORT:-8080}

// Standard Bean Validation annotations
@NotNull @NotEmpty @Valid @Min @Max @Range @Size @Pattern @Email

// Dropwizard-specific validation annotations
@DurationRange(min = 1, minUnit = TimeUnit.SECONDS, max = 1, maxUnit = TimeUnit.HOURS)
@MinDuration(value = 1, unit = TimeUnit.SECONDS)
@MaxDuration(value = 1, unit = TimeUnit.HOURS)

@DataSizeRange(min = 1, minUnit = DataSize.Unit.KILOBYTES, max = 1, maxUnit = DataSize.Unit.MEGABYTES)
@MinDataSize(value = 1, unit = DataSize.Unit.KILOBYTES)
@MaxDataSize(value = 1, unit = DataSize.Unit.MEGABYTES)

@OneOf({"value1", "value2", "value3"})
@PortRange(min = 1024, max = 65535)

@ValidationMethod(message = "Custom validation failed")

public class DatabaseConfiguration {
    @NotEmpty
    @Pattern(regexp = "jdbc:.*")
    private String url;
    
    @NotEmpty
    private String username;
    
    private String password = "";
    
    @Min(1) @Max(100)
    private int maxConnections = 10;
    
    @DurationRange(min = 1, minUnit = TimeUnit.SECONDS, max = 30, maxUnit = TimeUnit.SECONDS)
    private Duration connectionTimeout = Duration.seconds(5);
    
    @DataSizeRange(min = 1, minUnit = DataSize.Unit.KILOBYTES)
    private DataSize maxQuerySize = DataSize.megabytes(1);
    
    @ValidationMethod(message = "Password cannot be empty when username is provided")
    public boolean isPasswordValid() {
        return username.isEmpty() || !password.isEmpty();
    }
    
    // getters and setters with @JsonProperty
}

public class MyConfiguration extends Configuration {
    @Valid
    @NotNull
    private DatabaseConfiguration database = new DatabaseConfiguration();
    
    @Valid
    @NotNull
    private RedisConfiguration redis = new RedisConfiguration();
    
    @NotEmpty
    private String applicationName = "my-service";
    
    @OneOf({"development", "staging", "production"})
    private String environment = "development";
    
    @JsonProperty("database")
    public DatabaseConfiguration getDatabase() { return database; }
    
    @JsonProperty("database")
    public void setDatabase(DatabaseConfiguration database) { this.database = database; }
    
    // Additional getters and setters
}

// Property mapping
@JsonProperty("property_name")
@JsonAlias({"alias1", "alias2"})

// Inclusion/exclusion
@JsonIgnore
@JsonIgnoreProperties({"property1", "property2"})
@JsonIgnoreProperties(ignoreUnknown = true)

// Default values
@JsonProperty(defaultValue = "default_value")

// Custom serialization
@JsonSerialize(using = CustomSerializer.class)
@JsonDeserialize(using = CustomDeserializer.class)

// Property ordering
@JsonPropertyOrder({"prop1", "prop2", "prop3"})

@JsonIgnoreProperties(ignoreUnknown = true)
@JsonPropertyOrder({"name", "version", "environment"})
public class AppConfiguration {
    @JsonProperty("app_name")
    private String name;
    
    @JsonProperty(defaultValue = "1.0.0")
    private String version;
    
    @JsonIgnore
    private String internalProperty;
    
    @JsonSerialize(using = ToStringSerializer.class)
    @JsonDeserialize(using = DurationDeserializer.class)
    private Duration timeout;
}

# Example configuration file
applicationName: "My Service"
environment: ${ENVIRONMENT:-development}

server:
  applicationConnectors:
    - type: http
      port: ${PORT:-8080}
  adminConnectors:
    - type: http
      port: ${ADMIN_PORT:-8081}

database:
  driverClass: org.postgresql.Driver
  url: ${DATABASE_URL}
  username: ${DB_USERNAME}
  password: ${DB_PASSWORD}
  maxWaitForConnection: 1s
  validationQuery: "SELECT 1"
  properties:
    hibernate.dialect: org.hibernate.dialect.PostgreSQLDialect

logging:
  level: INFO
  loggers:
    com.example: DEBUG
  appenders:
    - type: console
    - type: file
      currentLogFilename: ./logs/application.log
      archivedLogFilenamePattern: ./logs/application-%d.log.gz
      archivedFileCount: 5

{
  "applicationName": "My Service",
  "server": {
    "applicationConnectors": [{
      "type": "http",
      "port": 8080
    }]
  },
  "database": {
    "url": "jdbc:postgresql://localhost/mydb",
    "username": "user",
    "password": "pass"
  }
}