Где будешь хранить URL для подключения к БД в приложении?

Где хранить URL для подключения к БД в приложении?

Это критически важный вопрос безопасности и конфигурируемости приложения. Правильный выбор влияет на безопасность, развертывание и поддерживаемость кода.

НИКОГДА не делай так (НЕБЕЗОПАСНО)

// ПЛОХО: hardcoded в коде
public class DatabaseConfig {
    private static final String DB_URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String USERNAME = "admin";
    private static final String PASSWORD = "password123";
    
    public static DataSource createDataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(DB_URL);
        ds.setUsername(USERNAME);
        ds.setPassword(PASSWORD);
        return ds;
    }
}

// Проблемы:
// - Логин и пароль в исходном коде
// - Один URL для всех окружений (dev, test, prod)
// - Невозможно менять без пересборки
// - Утечка секретов при коммите в git

Способ 1: Environment Variables (для production)

// application.properties НЕ содержит чувствительные данные
public class DatabaseConfig {
    
    @Bean
    public DataSource dataSource() {
        HikariDataSource ds = new HikariDataSource();
        
        // Читаем из переменных окружения
        ds.setJdbcUrl(System.getenv("DB_URL"));
        ds.setUsername(System.getenv("DB_USER"));
        ds.setPassword(System.getenv("DB_PASSWORD"));
        
        return ds;
    }
}

// При запуске контейнера (Docker):
// docker run -e DB_URL=jdbc:mysql://db.prod.com:3306/mydb \
//           -e DB_USER=admin \
//           -e DB_PASSWORD=<strong_password> \
//           myapp:latest

Способ 2: application.properties (с профилями)

Это наиболее распространенный подход в Spring Boot:

# application.properties (общие настройки)
spring.application.name=myapp
spring.jpa.hibernate.ddl-auto=validate

# application-dev.properties (локальная разработка)
spring.datasource.url=jdbc:mysql://localhost:3306/mydb_dev
spring.datasource.username=devuser
spring.datasource.password=devpass123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# application-test.properties (тестирование)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=

# application-prod.properties (production - НЕ коммитим!)
spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASSWORD}

// Java конфигурация
@Configuration
public class DataSourceConfig {
    
    @Bean
    public DataSource dataSource(
        @Value("${spring.datasource.url}") String url,
        @Value("${spring.datasource.username}") String username,
        @Value("${spring.datasource.password}") String password
    ) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

// Запуск с профилем:
// java -jar app.jar --spring.profiles.active=dev
// java -jar app.jar --spring.profiles.active=prod

Способ 3: application.yml (YAML формат)

# application.yml
spring:
  datasource:
    url: ${DB_URL:jdbc:mysql://localhost:3306/mydb}
    username: ${DB_USER:user}
    password: ${DB_PASSWORD:password}
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: false

---
spring:
  config:
    activate:
      on-profile: dev
  jpa:
    show-sql: true

---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5

Способ 4: ConfigMap в Kubernetes

Для cloud-native приложений:

# k8s-configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  application.yml: |
    spring:
      datasource:
        url: jdbc:mysql://mysql-service:3306/mydb
        username: myuser
        hikari:
          maximum-pool-size: 20

---
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  password: base64encodedpassword

# k8s-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    spec:
      containers:
      - name: app
        image: myapp:latest
        env:
        - name: SPRING_DATASOURCE_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password
        volumeMounts:
        - name: config
          mountPath: /config
      volumes:
      - name: config
        configMap:
          name: app-config

Способ 5: Vault (для чувствительных данных)

Для enterprise приложений:

// Maven dependency
// <dependency>
//     <groupId>org.springframework.cloud</groupId>
//     <artifactId>spring-cloud-vault-config</artifactId>
// </dependency>

// bootstrap.yml
spring:
  cloud:
    vault:
      uri: https://vault.company.com:8200
      token: ${VAULT_TOKEN}
      generic:
        enabled: true
        backend-path: secret

// Java код
@Configuration
public class VaultConfig {
    
    @Bean
    public DataSource dataSource(
        @Value("${vault:secret/database/prod/url}") String url,
        @Value("${vault:secret/database/prod/username}") String username,
        @Value("${vault:secret/database/prod/password}") String password
    ) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

Правильная структура проекта

myapp/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/company/
│   │   │       └── config/
│   │   │           └── DataSourceConfig.java
│   │   └── resources/
│   │       ├── application.yml           # Основная
│   │       ├── application-dev.yml       # Для разработки
│   │       └── application-prod.yml      # Gitignore!
│   └── test/
│       └── resources/
│           └── application-test.yml
└── .gitignore
    # application-prod.yml
    # application.properties.prod

.gitignore

# Конфигурационные файлы с секретами
application-prod.yml
application-prod.properties
application-staging.properties

# Файлы переменных окружения
.env
.env.local
.env.prod

# IDE
.idea/
.vscode/

# Build
target/
out/

Рекомендуемый подход для разных окружений

Полный пример (Best Practice)

# application.yml
spring:
  application:
    name: myapp
  datasource:
    url: ${DB_URL:jdbc:mysql://localhost:3306/mydb}
    username: ${DB_USER:root}
    password: ${DB_PASSWORD:}
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 10
      minimum-idle: 2
      connection-timeout: 20000
      idle-timeout: 300000
  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        format_sql: true

@Configuration
@EnableTransactionManagement
public class DatabaseConfiguration {
    
    @Bean
    public DataSource dataSource(
        @Value("${spring.datasource.url}") String url,
        @Value("${spring.datasource.username}") String username,
        @Value("${spring.datasource.password}") String password
    ) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(url);
        config.setUsername(username);
        config.setPassword(password);
        config.setMaximumPoolSize(10);
        config.setMinimumIdle(2);
        return new HikariDataSource(config);
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

Запуск приложения

# Локальная разработка
java -jar app.jar --spring.profiles.active=dev

# Тестирование
java -jar app.jar --spring.profiles.active=test

# Production с переменными окружения
export DB_URL="jdbc:mysql://prod-db.example.com:3306/mydb"
export DB_USER="produser"
export DB_PASSWORD="${VAULT_DB_PASSWORD}"
java -jar app.jar --spring.profiles.active=prod

# Или через Docker
docker run \
  -e DB_URL="jdbc:mysql://db:3306/mydb" \
  -e DB_USER="user" \
  -e DB_PASSWORD="password" \
  myapp:latest

Итог

Никогда не hardcode, используй:

1. Локальная разработка: application-dev.yml в репозитории
2. Тестирование: application-test.yml с in-memory БД
3. Production: Environment Variables или Vault

Правила:

• Никогда не коммитить application-prod.yml
• Использовать ${VAR_NAME:default} для переменных окружения
• Разные профили для разных окружений
• Чувствительные данные в переменных окружения, не в коде
• Регулярно ротировать пароли

Всегда помни: конфигурация должна быть отделена от кода, а секреты должны быть дополнительно защищены.