Ausführliche Erklärung von Spring's Profile

Vorwort

Die Profilfunktion in Spring gibt es tatsächlich schon seit Spring 3.1. Sie kann als die Logik der Beans verstanden werden, die wir im Spring-Container definieren Gruppenname Nur wenn diese Profile aktiviert sind, werden die dem Profil entsprechenden Beans im Spring-Container registriert.

Wenn Sie das Schlüsselwort Profil sehen, haben Sie es sich vielleicht noch nie direkt angesehen, oder Sie haben einige vage Eindrücke im Kopf. Zusätzlich zum Profil gibt es hier in Springmvc auch das Profil Tag in Maven.

Wörtlich bedeutet Profil Profil. Unter welchen Umständen wird die Profilfunktion verwendet und was ist die spezifische Bedeutung von Profil?

Zum Beispiel für eine Datenbank Bei Konfigurationsproblemen, aus der Perspektive Während der Entwicklung können Sie die eingebettete Datenbank verwenden und Testdaten laden (Codebeispiele folgen später). Aber aus Testgründen kann ein Datenbankverbindungspool so ausgestattet sein

@Bean（destroyMethod="close"）
public DataSource dataSource () {
 BasicDataSource dataSource = new BasicDataSource();
 dataSource.setUrl("jdbc:h2:tcp://dbserver/~/test");
 dataSource.setDriverClassName("org.h2.Driver");
 dataSource.setUsername("sa");
 dataSource.setPassword("password");
 dataSource.setInitialSize(20);
 dataSource.setMaxActive(30);
 return dataSource; 
}

Natürlich gibt es auch Konfigurationen in der Produktionsumgebung usw . Was können Sie noch über diese Art von Konfigurationsmethode sagen, die hundert Blumen zum Blühen bringt? Sie stellt stillschweigend entsprechende Konfigurationsdateien für diese Umgebungen bereit. Wir haben dies immer ohne Profile gemacht.

Aber jetzt haben wir mit Profile eine weitere Wahl, eine intelligentere und sorgenfreiere Konfigurationsmethode. Durch die Profilkonfiguration kann Spring entsprechend der Umgebung entscheiden, ob während der Ausführungsphase eine Bean erstellt wird. Das Folgende ist ein Beispiel, das hauptsächlich mit der Konfiguration und Aktivierung von Profil-Beans beginnt.

Konfiguration der Profil-Bean

Konfigurieren durch Annotieren von @Profile

Für das obige Beispiel In Im ersten Fall konfigurieren wir in der Entwicklungsumgebung eine Datenquelle wie diese. Sie ist in der Datei schema.sql unter der Klassendatei

schema.sql

@Bean(destroyMethod = "shutdown")
public DataSource embeddedDataSource() {
 return new EmbeddedDatabaseBuilder()
 .addScript("classpath:schema.sql")
 .addScript("classpath:test-data.sql")
 .build();
 }

< definiert 🎜>

Es wird hier definiert. Eine Things-Tabelle enthält zwei Felder

Zusätzlich zur Schemadatei müssen Testdaten auch über test-data.sql geladen werden

create table Things (
 id identity,
 name varchar(100)
);

test-data.sql

Ich weiß nicht, ob dieses @Bean erstellt wurde eine Entwicklungsumgebung oder eine Produktumgebung. Daher können wir hier die Annotation @Profile verwenden, um diese Bean zu kennzeichnen.

Die Bean-Profilfunktion wurde in Spring Version 3.1 eingeführt, mit der Sie verschiedene Beans in einem oder mehreren Profilen definieren können. Bei der Bereitstellung der Anwendung werden Sie dann benachrichtigt, welches Profil aktiviert werden soll, und die entsprechende Bean wird aktiviert erstellt werden.

insert into Things (name) values ('A')

Zum Beispiel hier

Markieren Sie die EmbedderDataSource-Bean bis , die im Entwickler erstellt werden soll Umweltbohnen.

Hinweis: 1. @Profile wird auf Klassenebene geladen. Wenn das Entwicklungsprofil nicht aktiviert ist, werden nicht alle entsprechenden Beans in der Klasse erstellt

@Configuration
@Profile("dev")
public class DevelopmentProfileConfig {

 @Bean(destroyMethod = "shutdown")
 public DataSource embeddedDataSource() {
 return new EmbeddedDatabaseBuilder()
 .setType(EmbeddedDatabaseType.H2)
 .addScript("classpath:schema.sql")
 .addScript("classpath:test-data.sql")
 .build();
 }
}

2. Wenn ja Wenn derzeit eine Entwicklungsumgebung aktiviert ist, werden Beans erstellt, die kein @Profile verwenden. Wenn sie als andere Profile wie z. B. prod markiert sind, werden die entsprechenden Beans nicht erstellt

3. Ab 3.2 wird @ erstellt. Das Profil kann nicht nur die Klassenebene laden, Sie können auch die Methode laden. Der spezifische Code lautet wie folgt

@Profile("dev")

Konfigurieren Sie über die XML-Konfigurationsdatei

Zusätzlich zu einfachen Anmerkungen können wir es in der XML-Konfigurationsdatei deklarieren. Die spezifische Konfiguration lautet wie folgt:

package com.myapp;

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
import org.springframework.jndi.JndiObjectFactoryBean;

@Configuration
public class DataSourceConfig {
 
 @Bean(destroyMethod = "shutdown")
 @Profile("dev")
 public DataSource embeddedDataSource() {
 return new EmbeddedDatabaseBuilder()
 .setType(EmbeddedDatabaseType.H2)
 .addScript("classpath:schema.sql")
 .addScript("classpath:test-data.sql")
 .build();
 }

 @Bean
 @Profile("prod")
 public DataSource jndiDataSource() {
 JndiObjectFactoryBean jndiObjectFactoryBean = new JndiObjectFactoryBean();
 jndiObjectFactoryBean.setJndiName("jdbc/myDS");
 jndiObjectFactoryBean.setResourceRef(true);
 jndiObjectFactoryBean.setProxyInterface(javax.sql.DataSource.class);
 return (DataSource) jndiObjectFactoryBean.getObject();
 }

}

datasource-config.xml

Hier werden zwei Umgebungen und entsprechende Profile deklariert.

Profilaktivierung

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
 xmlns:jee="http://www.springframework.org/schema/jee" xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="
 http://www.php.cn/
 http://www.php.cn/
 http://www.php.cn/
 http://www.php.cn/
 http://www.php.cn/
 http://www.php.cn/">

 <beans profile="dev">
 <jdbc:embedded-database type="H2">
 <jdbc:script location="classpath:schema.sql" />
 <jdbc:script location="classpath:test-data.sql" />
 </jdbc:embedded-database>
 </beans>
 
 <beans profile="prod">
 <jee:jndi-lookup 
 lazy-init="true"
 jndi-name="jdbc/myDatabase"
 resource-ref="true"
 proxy-interface="javax.sql.DataSource" />
 </beans>
</beans>

Obwohl wir das Profil konfiguriert haben, erfahren Sie, wie Sie die entsprechende Umgebung aktivieren. Hier benötigen wir zwei Attribute

und

.

Wenn ein Wert zugewiesen ist, wird nicht wirksam. Wenn

kein Wert zugewiesen ist, wird der durch

festgelegte Standardwert verwendet. Wenn keines von beiden festgelegt ist, werden natürlich nur die Beans erstellt, die im entsprechenden Profil definiert sind. spring.profile.activespring.profile.default

Es gibt viele Möglichkeiten, diese beiden Eigenschaften festzulegen:

spring.profile.activespring.profile.defaultAls Initialisierungsparameter von DispactcherServletspring.profie.activespring.profile.defaultAls Webanwendungskontextparameter

Als JNDI-Eintrag Als Umgebungsvariable

Als JVM-Systemeigenschaft

Verwenden Sie in der Integrationstestklasse die Annotation @ActiveProfiles, um

festzulegen Zum Beispiel sind wir im Web. Der Code in .xml kann wie folgt deklariert werden:

Auf diese Weise können Sie angeben, welche Umgebung vorhanden sein muss starten und die entsprechenden Bohnen zubereiten.

Warum stellt Spring zum Testen außerdem eine einfache Annotation mit @ActiveProfiles bereit, mit der angegeben werden kann, welches Profil beim Ausführen des Tests aktiviert werden soll? Beispielsweise führt die Testklasse DevDataSourceTest

<?xml version="1.0" encoding="UTF-8"?>
<web -app version="2.5"
...>

 //为上下文设置默认的profile
 <context-param>
 <param-name>spring.profile.default</param-name>
 <param-value>dev</param-value>
 </context-param>

...

 <servlet>
 ...
 //为Serlvet设置默认的profile
 <init-param>
  <param-name>spring-profiles.default</param-name>
  <param-value>dev</param-value>
 </init-prama>

...
<web-app>

die Methode ShouldBeEmbeddedDatasource aus und der Test besteht

Ausführlichere Artikel zu Spring’s Profile finden Sie auf der chinesischen PHP-Website!