TOC

Federprofile

Federprofile

1. Überblick

In diesem Artikel konzentrieren wir uns auf die Einführung vonProfiles in Spring.

Profile sind ein Kernmerkmal des Frameworks, mit dem wir unsere Beans verschiedenen Profilen zuordnen können, z. B.dev,test,prod.

Wir können dann verschiedene Profile in verschiedenen Umgebungen aktivieren, um genau die Beans zu booten, die wir benötigen:

Weitere Lektüre:

Separate Spring DataSource für Tests konfigurieren

Ein schnelles, praktisches Tutorial zum Konfigurieren einer separaten Datenquelle zum Testen in einer Spring-Anwendung.

Read more →

Eigenschaften mit Feder und Spring Boot

Lernprogramm zum Arbeiten mit Eigenschaftendateien und Eigenschaftswerten in Spring.

Read more →

2. Verwenden Sie@Profile für eine Bohne

Beginnen wir einfach und schauen wir uns an, wie wir eine Bohne zu einem bestimmten Profil gehören lassen können. Mit der Annotation@Profile ordnen wir die Bean diesem bestimmten Profil zu. Die Anmerkung enthält einfach die Namen eines (oder mehrerer) Profile.

Stellen Sie sich ein Basisszenario vor - wir haben eine Bean, die nur während der Entwicklung aktiv sein sollte, aber nicht in der Produktion bereitgestellt wird. Wir kommentieren diese Bean mit einem "dev" -Profil und sie wird nur während der Entwicklung im Container vorhanden sein - in der Produktion sind diedev einfach nicht aktiv: 

@Component
@Profile("dev")
public class DevDatasourceConfig

Als kurze Ergänzung kann den Profilnamen auch ein NOT-Operator vorangestellt werden, z. „!dev“, um sie von einem Profil auszuschließen.

Im folgenden Beispiel wird die Komponente nur aktiviert, wenn das Profil "dev" nicht aktiv ist: 

@Component
@Profile("!dev")
public class DevDatasourceConfig

3. Deklarieren Sie Profile in XML

Profile können auch in XML konfiguriert werden. Das Tag<beans>hat das Attribut“profiles”, das durch Kommas getrennte Werte der entsprechenden Profile verwendet:

4. Profile festlegen

Im nächsten Schritt müssen die Profile aktiviert und so eingestellt werden, dass die jeweiligen Beans im Container registriert sind.

Dies kann auf verschiedene Arten geschehen - die wir in den folgenden Abschnitten untersuchen werden.

4.1. Programmatisch über die Schnittstelle vonWebApplicationInitializer

In Webanwendungen könnenWebApplicationInitializer verwendet werden, umServletContext programmgesteuert zu konfigurieren.

Es ist auch ein sehr praktischer Ort, um unsere aktiven Profile programmgesteuert festzulegen: 

@Configuration
public class MyWebApplicationInitializer
  implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {

        servletContext.setInitParameter(
          "spring.profiles.active", "dev");
    }
}

4.2. Programmatisch überConfigurableEnvironment

Sie können Profile auch direkt in der Umgebung festlegen: 

@Autowired
private ConfigurableEnvironment env;
...
env.setActiveProfiles("someProfile");

4.3. Kontextparameter inweb.xml

In ähnlicher Weise auchprofiles can be activated in the web.xml der Webanwendung unter Verwendung eines Kontextparameters: 


    contextConfigLocation
    /WEB-INF/app-config.xml


    spring.profiles.active
    dev

4.4. JVM-Systemparameter

Die Profilnamen können auch über einen JVM-Systemparameter übergeben werden. Die als Parameter übergebenen Profilnamen werden beim Start der Anwendung aktiviert: 

-Dspring.profiles.active=dev

4.5. Umgebungsvariable

In einer Unix-Umgebung sindprofiles can also be activated via the environment variable: 

export spring_profiles_active=dev

4.6. Maven-Profil

Federprofile können auch über Maven-Profile aktiviert werden, indem die Sconfigurationseigenschaftspring.profiles.active angegeben wird.

In jedem Maven-Profil können wir die Eigenschaftspring.profiles.activefestlegen: 


    
        dev
        
            true
        
        
            dev
        
    
    
        prod
        
            prod

Sein Wert wird verwendet, um den Platzhalter von@[email protected]inapplication.properties zu ersetzen: 

[email protected]@

Jetzt müssen wir die Ressourcenfilterung inpom.xml aktivieren: 


    
        
            src/main/resources
            true
        
    
    ...

Fügen Sie einen-P-Parameter hinzu, um zu wechseln, welches Maven-Profil angewendet wird: 

mvn clean package -Pprod

Dieser Befehl packt die Anwendung für das Profil vonprod. Es wendet auch denspring.profiles.active -Wert‘prod' für diese Anwendung an, wenn sie ausgeführt wird.

4.7. @ActiveProfile in Tests

Mithilfe von Tests können Sie ganz einfach angeben, welche Profile aktiv sind. Verwenden Sie die Annotation@ActiveProfile, um bestimmte Profile zu aktivieren: 

@ActiveProfiles("dev")

Zusammenfassend haben wir uns mehrere Möglichkeiten angesehen, Profile zu aktivieren. Lassen Sie uns nun sehen, welche Priorität hat und welche passiert, wenn Sie mehr als eine verwenden - von der höchsten zur niedrigsten Priorität:

  1. Kontextparameter inweb.xml

  2. WebApplicationInitializer

  3. JVM-Systemparameter

  4. Umgebungsvariable

  5. Maven-Profil

5. Das Standardprofil

Jede Bean, die kein Profil angibt, gehört zum Profil "default".

Spring bietet auch eine Möglichkeit, das Standardprofil festzulegen, wenn kein anderes Profil aktiv ist - mithilfe der Eigenschaft "spring.profiles.default".

6. Aktive Profile abrufen

Die aktiven Profile von Spring steuern das Verhalten der Annotation@Profilezum Aktivieren / Deaktivieren von Beans. Möglicherweise möchten wir jedoch auch programmgesteuert auf die Liste der aktiven Profile zugreifen.

Wir haben zwei Möglichkeiten:using Environment or*spring.active.profile*.

6.1. Verwenden vonEnvironment

Wir können vom ObjektEnvironmentauf die aktiven Profile zugreifen, indem wir es einfügen: 

public class ProfileManager {
    @Autowired
    private Environment environment;

    public void getActiveProfiles() {
        for (String profileName : environment.getActiveProfiles()) {
            System.out.println("Currently active profile - " + profileName);
        }  
    }
}

6.2. Verwenden vonspring.active.profile

Alternativ können wir auf die Profile zugreifen, indem wir die Eigenschaftspring.profiles.active einfügen: 

@Value("${spring.profiles.active}")
private String activeProfile;

Hier ist unsereactiveProfile-Variablewill contain the name of the profile that is currently active, und wenn es mehrere gibt, enthält sie ihre Namen, die durch ein Komma getrennt sind.

Wir sollten jedochconsider what would happen if there is no active profile at all. In unserem obigen Code würde das Fehlen eines aktiven Profils die Erstellung des Anwendungskontexts verhindern. Dies würde aufgrund des fehlenden Platzhalters zum Einfügen in die Variable zu einemIllegalArgumentExceptionführen.

Um dies zu vermeiden, können wirdefine a default value: 

@Value("${spring.profiles.active:}")
private String activeProfile;

Wenn jetzt keine Profile aktiv sind, enthalten unsereactiveProfile nur eine leere Zeichenfolge. Und wenn wir wie im vorherigen Beispiel auf die Liste zugreifen möchten, können wir dies mitsplitting der VariablenactiveProfiletun: 

public class ProfileManager {
    @Value("${spring.profiles.active:}")
    private String activeProfiles;

    public String getActiveProfiles() {
        for (String profileName : activeProfiles.split(",")) {
            System.out.println("Currently active profile - " + profileName);
        }
    }
}

7. Beispiel für die Verwendung von Profilen

Nachdem die Grundlagen nicht mehr im Weg sind, schauen wir uns ein reales Beispiel an.

Stellen Sie sich ein Szenario vor, in dem die Datenquellenkonfiguration sowohl für die Entwicklungs- als auch für die Produktionsumgebung verwaltet werden muss. Erstellen wir eine gemeinsame SchnittstelleDatasourceConfig, die von beiden Datenquellenimplementierungen implementiert werden muss: 

public interface DatasourceConfig {
    public void setup();
}

Es folgt die Konfiguration für die Entwicklungsumgebung: 

@Component
@Profile("dev")
public class DevDatasourceConfig implements DatasourceConfig {
    @Override
    public void setup() {
        System.out.println("Setting up datasource for DEV environment. ");
    }
}

Und Konfiguration für die Produktionsumgebung: 

@Component
@Profile("production")
public class ProductionDatasourceConfig implements DatasourceConfig {
    @Override
    public void setup() {
       System.out.println("Setting up datasource for PRODUCTION environment. ");
    }
}

Jetzt erstellen wir einen Test und fügen unsere DatasourceConfig-Schnittstelle ein. Abhängig vom aktiven Profil injiziert SpringDevDatasourceConfig oderProductionDatasourceConfig Bean: 

public class SpringProfilesWithMavenPropertiesIntegrationTest {
    @Autowired
    DatasourceConfig datasourceConfig;

    public void setupDatasource() {
        datasourceConfig.setup();
    }
}

Wenn das Profil "dev" aktiv ist, injiziert die Feder das Objekt vonDevDatasourceConfig, und beim Aufruf der Methode vonsetup()folgt die folgende Methode: 

Setting up datasource for DEV environment.

8. Profile im Spring Boot

Spring Boot unterstützt alle bisher beschriebenen Profilkonfigurationen mit einigen zusätzlichen Funktionen.

Der in Abschnitt 4 eingeführte Initialisierungsparameterspring.profiles.active kann auch in Spring Boot als Eigenschaft eingerichtet werden, um aktuell aktive Profile zu definieren. Dies ist eine Standardeigenschaft, die Spring Boot automatisch aufnimmt: 

spring.profiles.active=dev

Um Profile programmgesteuert festzulegen, können wir auch die KlasseSpringApplicationverwenden: 

SpringApplication.setAdditionalProfiles("dev");

Um Profile mit Maven in Spring Boot festzulegen, können Sie Profilnamen unterspring-boot-maven-plugin inpom.xml: angeben 


    
        org.springframework.boot
        spring-boot-maven-plugin
        
            
                dev
            
        
    
    ...

Und führen Sie das Spring Boot-spezifische Maven-Ziel aus: 

mvn spring-boot:run

Die wichtigste profilbezogene Funktion, die Spring Boot bietet, istprofile-specific properties files. Diese müssen im Formatapplications-{profile}.properties benannt werden.

Spring Boot lädt automatisch die Eigenschaften in eineapplication.properties-Datei für alle Profile und diejenigen in profilspezifischen.properties-Dateien nur für das angegebene Profil.

Beispielsweise können wir verschiedene Datenquellen fürdev- undproduction-Profile konfigurieren, indem wir zwei Dateien mit den Namenapplication-dev.properties undapplication-production.properties verwenden:

In der Dateiapplication-production.properties können wir eine DatenquelleMySqleinrichten: 

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db
spring.datasource.username=root
spring.datasource.password=root

Anschließend können wir dieselben Eigenschaften für dasdev-Profil in derapplication-dev.properties-Datei konfigurieren, um eine speicherinterneH2-Datenbank zu verwenden: 

spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=sa

Auf diese Weise können wir problemlos verschiedene Konfigurationen für verschiedene Umgebungen bereitstellen.

9. Fazit

In diesem kurzen Tutorial haben wir besprochen, wiedefine a profile auf einer Bean und dannenable the right profiles in unserer Anwendung verwendet werden.

Schließlich haben wir unser Verständnis von Profilen anhand eines einfachen, aber dennoch realen Beispiels bestätigt.

Die Implementierung dieses Spring Security REST-Tutorials finden Sie inthe GitHub project - dies ist ein Maven-basiertes Projekt, daher sollte es einfach zu importieren und auszuführen sein.

Related