Spring Profiles bieten eine leistungsstarke Möglichkeit, Teile Ihrer Anwendungskonfiguration zu trennen und sie nur in bestimmten Umgebungen verfügbar zu machen. Diese Funktion ist besonders nützlich, um verschiedene Konfigurationen für Entwicklungs-, Test- und Produktionsumgebungen zu verwalten, ohne Ihren Code zu ändern.

Was sind Federprofile?

Mit Spring-Profilen können Sie Beans abhängig vom aktiven Profil bedingt registrieren. Dies bedeutet, dass Sie mehrere Beans desselben Typs definieren und angeben können, welches in einer bestimmten Umgebung aktiv sein soll.

Einrichten von Federprofilen

1. Konfigurationsdateien erstellen

Spring Boot verwendet eine Reihe von application-{profile}.properties- oder application-{profile}.yml-Dateien für die Konfiguration. Diese Dateien enthalten profilspezifische Konfigurationen und werden basierend auf dem aktiven Profil geladen.

Standardkonfiguration (application.yml)

spring:
  application:
    name: MySpringApp

server:
  port: 8080  # Default port

Entwicklungskonfiguration (application-dev.yml)

spring:
  datasource:
    url: jdbc:h2:mem:devdb
    username: sa
    password: ""
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

server:
  port: 8081  # Development port

Produktionskonfiguration (application-prod.yml)

spring:
  datasource:
    url: jdbc:mysql://prod-db-server:3306/proddb
    username: prod_user
    password: prod_password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

server:
  port: 8082  # Production port

Federprofile aktivieren

2. Profile über die Befehlszeile aktivieren

Sie können ein Profil aktivieren, indem Sie den Parameter --spring.profiles.active verwenden, wenn Sie Ihre Spring Boot-Anwendung ausführen:

java -jar my-spring-app.jar --spring.profiles.active=dev

3. Aktivieren von Profilen über Anwendungseigenschaften

Alternativ können Sie das aktive Profil in Ihrer application.yml-Datei angeben:

spring:
  profiles:
    active: dev  # or prod

4. Aktivieren von Profilen über Umgebungsvariablen

Sie können das aktive Profil auch mithilfe einer Umgebungsvariablen festlegen:

export SPRING_PROFILES_ACTIVE=dev

Verwenden von Profilen im Code

Spring stellt eine @Profile-Annotation bereit, um Beans basierend auf dem aktiven Profil bedingt zu registrieren. Hier ist ein Beispiel:

Beispielkonfigurationsklassen

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

@Configuration
public class AppConfig {

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new HikariDataSource();  // Development-specific DataSource
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return new HikariDataSource();  // Production-specific DataSource
    }
}

In diesem Beispiel wird die devDataSource-Bean nur erstellt, wenn das Entwicklungsprofil aktiv ist, und die prodDataSource-Bean wird erstellt, wenn das Produktprofil aktiv ist.

Testen profilspezifischer Beans

Beim Schreiben von Tests können Sie mithilfe der Annotation @ActiveProfiles angeben, welche Profile aktiv sein sollen:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;

@SpringBootTest
@ActiveProfiles("dev")
public class DevProfileTests {

    @Autowired
    private DataSource dataSource;

    @Test
    public void testDataSource() {
        // Test code using the development DataSource
    }
}

Profilspezifische Eigenschaften

Manchmal möchten Sie möglicherweise unterschiedliche Eigenschaftendateien basierend auf dem aktiven Profil laden. Sie können die Annotation @PropertySource verwenden, um dies zu erreichen:

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

@Configuration
@PropertySource("classpath:application-${spring.profiles.active}.properties")
public class PropertyConfig {
}

Abschluss

Spring-Profile sind eine robuste und flexible Möglichkeit, verschiedene Konfigurationen für verschiedene Umgebungen zu verwalten. Durch die Trennung Ihrer Konfigurationseigenschaften und Beans nach Profilen können Sie sicherstellen, dass sich Ihre Anwendung in jeder Umgebung korrekt verhält, sei es in der Entwicklung, beim Testen oder in der Produktion. Mit den in diesem Artikel beschriebenen Techniken können Sie Profile in Ihrer Spring Boot-Anwendung einfach einrichten und verwalten.