Какой способ конфигурации предпочитаешь?

Предпочтительные подходы к конфигурации приложений

Мой выбор: Environment Variables + YAML (иерархическая структура)

Скажу сразу мой preference, а потом объясню почему: я предпочитаю комбинированный подход:

1. Environment Variables для secrets и критичных параметров
2. YAML конфигурация для большинства настроек
3. Type-safe properties classes в коде для безопасности

Это даёт лучший баланс между безопасностью, гибкостью и читаемостью.

Вариант 1: Properties файлы (.properties)

Плюсы:

• Простой формат
• Встроен в Java
• Малый overhead

Минусы:

• Нет иерархии
• Плоская структура
• Сложно читать большие файлы

# application.properties
app.name=MyApp
app.version=1.0.0
db.host=localhost
db.port=5432
db.username=user
db.password=pass
db.pool.min-size=5
db.pool.max-size=20
server.port=8080
server.servlet.context-path=/api

Код:

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
    @Value("${app.name}")
    private String appName;
    
    @Value("${db.host}")
    private String dbHost;
}

Вариант 2: YAML конфигурация (рекомендуемый)

Плюсы:

• Иерархическая структура
• Хорошо читаема
• Поддерживает вложенные объекты
• По умолчанию в Spring Boot

Минусы:

• Чувствителен к отступам
• Требует yaml-processor

# application.yml
app:
  name: MyApp
  version: 1.0.0
  features:
    cache-enabled: true
    async-processing: false

db:
  host: localhost
  port: 5432
  username: user
  password: ${DB_PASSWORD}  # Из env переменной
  pool:
    min-size: 5
    max-size: 20
  
server:
  port: 8080
  servlet:
    context-path: /api
  compression:
    enabled: true
    min-response-size: 1024

logging:
  level:
    root: INFO
    com.example: DEBUG
  pattern: "%d %logger{36} - %msg%n"

Код с Type-Safe Properties:

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;
    private Features features = new Features();
    
    public static class Features {
        private boolean cacheEnabled;
        private boolean asyncProcessing;
        // getters/setters
    }
    
    // getters/setters
}

@Configuration
@ConfigurationProperties(prefix = "db")
public class DatabaseProperties {
    private String host;
    private int port;
    private String username;
    private String password;
    private Pool pool = new Pool();
    
    public static class Pool {
        private int minSize;
        private int maxSize;
        // getters/setters
    }
    // getters/setters
}

// Использование
@Service
public class AppService {
    private final AppProperties appProperties;
    private final DatabaseProperties dbProperties;
    
    public AppService(AppProperties appProperties, DatabaseProperties dbProperties) {
        this.appProperties = appProperties;
        this.dbProperties = dbProperties;
    }
    
    public void info() {
        System.out.println("App: " + appProperties.getName());
        System.out.println("DB Host: " + dbProperties.getHost());
    }
}

Вариант 3: Environment Variables

Плюсы:

• Очень безопасно для secrets
• Docker/Kubernetes friendly
• Скрывает sensitive информацию

Минусы:

• Сложно управлять большим количеством
• Нет типизации
• Нет иерархии

// Прямое использование
public class EnvConfig {
    public static final String DB_HOST = System.getenv("DB_HOST");
    public static final String DB_PORT = System.getenv("DB_PORT");
    public static final String API_KEY = System.getenv("API_KEY");
}

// Или через @Value
@Component
public class ApiClient {
    @Value("${API_KEY:default-key}")  // default-key если не установлено
    private String apiKey;
    
    @Value("${API_ENDPOINT:https://api.example.com}")
    private String endpoint;
}

Вариант 4: Java-based конфигурация

Плюсы:

• Полная типизация
• IDE автозаполнение
• Логика можно встроить

Минусы:

• Нужно перекомпилировать для изменения
• Много boilerplate кода

@Configuration
public class AppConfig {
    
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create()
            .driverClassName("org.postgresql.Driver")
            .url("jdbc:postgresql://localhost:5432/mydb")
            .username("user")
            .password("pass")
            .build();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("users", "products");
    }
}

Вариант 5: ConfigMap + Secrets (Kubernetes)

Для production в K8s:

# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  application.yml: |
    app:
      name: MyApp
      version: 1.0.0
    logging:
      level: INFO

---
# secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
stringData:
  DB_PASSWORD: super-secret-password
  API_KEY: secret-api-key

// В Spring Boot приложении автоматически читается
@Value("${DB_PASSWORD}")
private String dbPassword;

Мой рекомендуемый подход для production

# Структура проекта
src/main/resources/
├── application.yml           # Дефолтные настройки
├── application-dev.yml       # Development
├── application-prod.yml      # Production
└── application-test.yml      # Testing

# application.yml
spring:
  application:
    name: my-app
  profiles:
    active: dev  # или prod для production

app:
  name: MyApp
  version: @project.version@  # Из Maven
  
db:
  host: ${DB_HOST:localhost}
  port: ${DB_PORT:5432}
  username: ${DB_USER}
  password: ${DB_PASSWORD}
  
authentication:
  jwt-secret: ${JWT_SECRET}
  jwt-expiration: 86400

logging:
  level:
    root: ${LOG_LEVEL:INFO}

# application-prod.yml
spring:
  jpa:
    hibernate:
      ddl-auto: validate  # Не автогенерируем схему
  
db:
  pool:
    minimum-idle: 10
    maximum-pool-size: 30

logging:
  level:
    root: WARN  # Меньше логирования в prod
    com.example: INFO

Иерархия конфигурации (Spring Boot)

Spring Boot загружает конфигурацию в этом порядке (позже переопределяет раньше):

1. application.properties
2. application.yml
3. application-{profile}.properties
4. application-{profile}.yml
5. Environment variables
6. System properties
7. Java code (@Configuration)

Type-Safe конфигурация (лучший подход)

@Configuration
@ConfigurationProperties(prefix = "app")
@Validated
public class AppConfig {
    @NotBlank
    private String name;
    
    @NotNull
    private String version;
    
    @Positive
    private int port;
    
    @Email
    private String adminEmail;
    
    // getters/setters
    // Валидация происходит автоматически!
}

Конкретный пример: микросервис

# application.yml
spring:
  application:
    name: user-service
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
  datasource:
    url: jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
    username: ${DB_USER}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
  cache:
    type: redis
    redis:
      host: ${REDIS_HOST}
      port: ${REDIS_PORT}

app:
  service:
    name: user-service
    version: ${app.version}
  features:
    cache-enabled: true
    async-email: true
  jwt:
    secret: ${JWT_SECRET}
    expiration: 86400

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus

Заключение

Мой выбор: YAML конфигурация + Type-Safe Properties + Environment Variables для secrets

Почему:

1. YAML — хорошо читаема и структурирована
2. Type-Safe Properties — безопасность типов, IDE поддержка
3. Environment Variables — для secrets, безопасно в Docker/K8s
4. Separation — разные конфиги для dev/test/prod
5. Простота — стандартный подход в Spring Boot экосистеме

Этот подход используют крупные компании (Netflix, Google, Amazon) в своих Java сервисах.