Explication détaillée du profil de Spring

Préface

La fonction Profile de Spring est en fait disponible dès Spring 3.1. Elle peut être comprise comme la logique des beans que nous définissons dans le conteneur Spring. Nom du groupe. Uniquement lorsque ces profils sont activés, les beans correspondant au profil seront enregistrés dans le conteneur Spring.

Lorsque vous voyez le mot-clé Profil, peut-être que vous ne l'avez jamais regardé directement, ou que vous avez peut-être de vagues impressions en tête. Par exemple, en plus du Profil dans Springmvc ici, il y a aussi le Profil. balise dans maven.

Littéralement, Profil signifie profil, alors dans quelles circonstances la fonction de profil est-elle utilisée, et quelle est la signification spécifique du profil

Par exemple, pour une base de données Pour les problèmes de configuration, du point de vue ? de développement, vous pouvez utiliser la base de données intégrée et charger les données de test (des exemples de code seront donnés plus tard). Mais aux yeux des tests, un pool de connexion à une base de données peut être équipé comme ça

@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; 
}

Bien sûr, il y a aussi des configurations dans l'environnement de production, etc . Que pouvez-vous dire d'autre sur ce type de méthode de configuration qui laisse fleurir une centaine de fleurs ? Elle déploie silencieusement les fichiers de configuration correspondants pour cet ensemble d'environnements. Nous avons toujours fait cela sans profils.

Mais maintenant, avec Profile, nous avons un choix supplémentaire, une méthode de configuration plus intelligente et sans souci. Grâce à la configuration du profil, Spring peut décider de créer ou non un bean pendant la phase d'exécution en fonction de l'environnement. Voici un exemple, commençant principalement à partir de la configuration et de l'activation des beans Profile.

Configuration du bean Profile

Configuration via l'annotation @Profile

Pour l'exemple ci-dessus Dans le premier cas, dans l'environnement de développement nous configurons une source de données comme celle-ci Défini dans le fichier schema.sql sous le fichier de classe

schema.sql

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

est défini ici Une table Things contient deux champs

En plus du fichier de schéma, les données de test doivent également être chargées via test-data.sql

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

test-data.sql

Je ne sais pas si ce @Bean est créé dans un environnement de développement ou un environnement de produit. Nous pouvons donc utiliser l'annotation @Profile ici pour nous aider à étiqueter ce bean.

La fonction de profil de bean a été introduite dans la version Spring 3.1, qui permet de définir différents beans dans un ou plusieurs profils, puis lors du déploiement de l'application, vous êtes averti quel profil activer, et le bean correspondant le fera être créé.

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

Par exemple, ici

Marquez le bean EmbedderDataSource via

à créer dans le haricots d’environnement de développement.

Remarque : 1. @Profile est chargé au niveau de la classe, si le profil dev n'est pas activé, alors tous les beans correspondants dans la classe ne seront pas créés

@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. Si c'est le cas actuellement un environnement de développement est activé, alors les beans qui n'utilisent pas @Profile seront créés s'ils sont marqués comme d'autres profils tels que prod, les beans correspondants ne seront pas créés

3. À partir de 3.2, @. Le profil peut non seulement charger les classes de niveau, vous pouvez également charger la méthode, le code spécifique est le suivant @Profile("dev")

Configurer via le fichier de configuration XML

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();
 }

}

En plus de simples annotations, nous pouvons le déclarer dans le fichier de configuration XML. La configuration spécifique est la suivante

datasource-config.xml<🎜. >

Deux environnements et profils correspondants sont déclarés ici respectivement.

Activation du profil

<?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>

Bien que nous ayons configuré le profil, comment activer l'environnement correspondant. Ici, nous avons besoin de deux attributs

et

.

Si se voit attribuer une valeur, ne prendra pas effet. Si

ne se voit pas attribuer de valeur, la valeur par défaut définie par

sera utilisée. Bien entendu, si aucun des deux n'est défini, seuls les beans définis dans le profil correspondant seront créés. spring.profile.activespring.profile.default

Il existe de nombreuses façons de définir ces deux propriétés :

spring.profile.activespring.profile.defaultEn tant que paramètres d'initialisation de DispactcherServletspring.profie.activespring.profile.defaultEn tant que paramètres de contexte d'application Web

En tant qu'entrée JNDI En tant que variable d'environnement

En tant que propriété système JVM

Sur la classe de test d'intégration, utilisez l'annotation @ActiveProfiles pour définir

Par exemple, nous sommes sur le web Le code en .xml peut être déclaré comme suit

De cette façon, vous pouvez spécifier quel environnement doit être démarré et préparez les haricots correspondants.

De plus, pour les tests, pourquoi spring fournit-il une simple annotation utilisant @ActiveProfiles, qui peut spécifier quel profil doit être activé lors de l'exécution du test. Par exemple, la classe de test 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>

exécute la méthode ShouldBeEmbeddedDatasource et le test réussit

Pour des articles plus détaillés sur le profil de Spring, veuillez faire attention au site Web PHP chinois !