Как настроить профили

# Настройка профилей (Profiles) в Spring

Профили (profiles) — это механизм в Spring Framework для управления конфигурацией приложения в разных окружениях (development, testing, production). Это позволяет иметь разные настройки для разных сценариев без изменения кода.

1. Использование @Profile аннотации

Основной способ активирования Bean в зависимости от профиля:

import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.Configuration;

// Только для development профиля
@Configuration
@Profile("dev")
public class DevConfig {
    
    @Bean
    public DataSource dataSource() {
        DataSource ds = new DataSource();
        ds.setUrl("jdbc:mysql://localhost:3306/myapp_dev");
        ds.setUsername("root");
        ds.setPassword("dev_password");
        return ds;
    }
    
    @Bean
    public EmailService emailService() {
        return new MockEmailService();  // Mock сервис для разработки
    }
}

// Только для production профиля
@Configuration
@Profile("prod")
public class ProdConfig {
    
    @Bean
    public DataSource dataSource() {
        DataSource ds = new DataSource();
        ds.setUrl("jdbc:mysql://prod-server:3306/myapp");
        ds.setUsername("prod_user");
        ds.setPassword(System.getenv("DB_PASSWORD"));
        return ds;
    }
    
    @Bean
    public EmailService emailService() {
        return new RealEmailService();  // Real сервис для production
    }
}

2. Активирование профилей

2.1 Через application.properties

# application.properties (основной файл)
spring.profiles.active=dev

# или несколько профилей через запятую
spring.profiles.active=dev,mysql

2.2 Через application.yml

# application.yml
spring:
  profiles:
    active: dev
    # или список
    include:
      - dev
      - mysql

2.3 Через переменную окружения

# При запуске приложения
java -jar myapp.jar --spring.profiles.active=prod

# Или через окружение
export SPRING_PROFILES_ACTIVE=prod
java -jar myapp.jar

2.4 Через программный код

public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        
        // Активируем профиль программно
        app.setAdditionalProfiles("prod", "mysql");
        
        app.run(args);
    }
}

3. Профильные файлы конфигурации

Лучшая практика — использовать отдельные файлы конфигурации для каждого профиля:

src/main/resources/
├── application.properties           # общие свойства
├── application-dev.properties       # для dev профиля
├── application-prod.properties      # для prod профиля
├── application-test.properties      # для test профиля
└── application-mysql.properties     # дополнительный профиль

application.properties

# общие свойства
app.name=MyApp
app.version=1.0.0

# подключаем профильные конфиги
spring.profiles.active=dev

application-dev.properties

# Development конфигурация
spring.datasource.url=jdbc:mysql://localhost:3306/myapp_dev
spring.datasource.username=root
spring.datasource.password=password

logging.level.root=DEBUG
logging.level.com.mycompany=TRACE

app.api.url=http://localhost:8080
app.email.enabled=false

application-prod.properties

# Production конфигурация
spring.datasource.url=jdbc:mysql://prod-db-server:3306/myapp
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASSWORD}

logging.level.root=WARN
logging.level.com.mycompany=INFO

app.api.url=https://api.example.com
app.email.enabled=true
app.email.smtp.host=smtp.gmail.com

4. @Profile на уровне методов Bean

@Configuration
public class AppConfig {
    
    // Для всех профилей кроме test
    @Bean
    @Profile("!test")
    public CacheService cacheService() {
        return new RedisCacheService();
    }
    
    // Только для test профиля
    @Bean
    @Profile("test")
    public CacheService cacheServiceTest() {
        return new MockCacheService();
    }
    
    // Для dev и test профилей
    @Bean
    @Profile({"dev", "test"})
    public LoggingService loggingService() {
        return new ConsoleLoggingService();
    }
    
    // Для всех профилей
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

5. @ConditionalOnProfile

Распространённая альтернатива для более сложных условий:

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

@Configuration
public class FeatureToggleConfig {
    
    @Bean
    @ConditionalOnProperty(name = "feature.analytics.enabled", havingValue = "true")
    public AnalyticsService analyticsService() {
        return new AnalyticsService();
    }
}

6. Использование @Value с профильными свойствами

@Component
public class ApiClient {
    
    @Value("${app.api.url}")
    private String apiUrl;
    
    @Value("${app.api.key}")
    private String apiKey;
    
    @Value("${app.timeout:5000}")  // default 5000
    private int timeout;
    
    public void makeRequest() {
        System.out.println("Calling: " + apiUrl);  // dev или prod URL
        // ...
    }
}

7. Примеры для разных сценариев

Database Profiles

# application-mysql.properties
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/myapp

# application-postgres.properties
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/myapp

# Запуск с MySQL
# java -jar app.jar --spring.profiles.active=dev,mysql

# Запуск с PostgreSQL
# java -jar app.jar --spring.profiles.active=dev,postgres

Environment-specific Configuration

# application.yml
spring:
  config:
    import: optional:file:.env.yml

  profiles:
    active:
      - ${SPRING_PROFILE:dev}

---  # Dev profile
spring:
  config:
    activate:
      on-profile: dev
      
logging:
  level: debug

app:
  mode: development
  debug: true

---  # Prod profile
spring:
  config:
    activate:
      on-profile: prod
      
logging:
  level: info

app:
  mode: production
  debug: false

8. Тестирование с профилями

import org.springframework.test.context.ActiveProfiles;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@ActiveProfiles("test")
public class UserServiceTest {
    
    @Autowired
    private UserService userService;  // будет использовать test конфигурацию
    
    @Test
    public void testUserCreation() {
        User user = userService.createUser("John");
        assertNotNull(user);
    }
}

// Для интеграционных тестов
@SpringBootTest
@ActiveProfiles({"test", "h2"})
public class IntegrationTest {
    // использует H2 in-memory БД для тестов
}

9. Проверка активных профилей

import org.springframework.core.env.Environment;

@Component
public class ProfileChecker {
    
    @Autowired
    private Environment env;
    
    public void printProfiles() {
        String[] profiles = env.getActiveProfiles();
        System.out.println("Active profiles: " + Arrays.toString(profiles));
        
        if (env.acceptsProfiles("prod")) {
            System.out.println("Running in Production mode");
        }
        
        if (env.acceptsProfiles("dev")) {
            System.out.println("Running in Development mode");
        }
        
        String apiUrl = env.getProperty("app.api.url");
        System.out.println("API URL: " + apiUrl);
    }
}

10. Стандартные профили в Spring Boot

# Spring Boot автоматически определяет профили:
# - "default" — если ничего не указано
# - "dev" — для разработки
# - "test" — для тестов (автоматически при @SpringBootTest)
# - "prod" — для production

Лучшие практики

1. Используйте отдельные файлы конфигурации для каждого профиля
2. Никогда не коммитьте production пароли — используйте переменные окружения
3. Используйте default значения в application.properties
4. Тестируйте все профили перед деплоем
5. Документируйте активные профили для каждого окружения
6. Используйте meaningful имена профилей (dev, prod, staging, qa)
7. Комбинируйте профили (dev + mysql, prod + postgres)

Типичная конфигурация для команды

# Development
java -jar app.jar --spring.profiles.active=dev,mysql

# Staging
java -jar app.jar --spring.profiles.active=staging,mysql

# Production
java -jar app.jar --spring.profiles.active=prod,postgres

# Testing
# автоматически используется --spring.profiles.active=test

Профили — это мощный инструмент для управления конфигурацией приложения, позволяющий одному коду работать в разных окружениях без изменений.