Qu'est-ce que le profil printanier ? En termes simples, un profil est un ensemble de configurations. Différents profils fournissent différentes combinaisons de configurations. Lorsque le programme est en cours d'exécution, vous pouvez choisir les profils à utiliser pour vous adapter à l'environnement. L'article suivant présente principalement les informations pertinentes sur la mise en œuvre réelle de Profile in Spring. Les amis dans le besoin peuvent s'y référer.
Préface
La fonction Profil de Spring est en fait disponible dès le Spring 3.1. On peut comprendre que nous sommes au Spring. conteneur Le nom de groupe logique du bean défini Ce n'est que lorsque ces profils sont activés que les beans correspondants dans le 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")
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.active
spring.profile.default
spring.profile.active
spring.profile.default
En tant que paramètres d'initialisation de DispactcherServletspring.profie.active
spring.profile.default
En 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.另外对于测试,spring为什么提供了一个简单的注解可以使用@ActiveProfiles,它可以指定运行测试的时候应该要激活那个profile。比如这里的测试类DevDataSourceTest
package profiles; import static org.junit.Assert.*; import java.sql.ResultSet; import java.sql.SQLException; import java.util.List; import javax.sql.DataSource; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.RowMapper; import org.springframework.test.context.ActiveProfiles; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import com.myapp.DataSourceConfig; public class DataSourceConfigTest { @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes=DataSourceConfig.class) @ActiveProfiles("dev") public static class DevDataSourceTest { @Autowired private DataSource dataSource; @Test public void shouldBeEmbeddedDatasource() { assertNotNull(dataSource); JdbcTemplate jdbc = new JdbcTemplate(dataSource); List<String> results = jdbc.query("select id, name from Things", new RowMapper<String>() { @Override public String mapRow(ResultSet rs, int rowNum) throws SQLException { return rs.getLong("id") + ":" + rs.getString("name"); } }); assertEquals(1, results.size()); assertEquals("1:A", results.get(0)); } } @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes=DataSourceConfig.class) @ActiveProfiles("prod") public static class ProductionDataSourceTest { @Autowired private DataSource dataSource; @Test public void shouldBeEmbeddedDatasource() { // should be null, because there isn't a datasource configured in JNDI assertNull(dataSource); } } @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:datasource-config.xml") @ActiveProfiles("dev") public static class DevDataSourceTest_XMLConfig { @Autowired private DataSource dataSource; @Test public void shouldBeEmbeddedDatasource() { assertNotNull(dataSource); JdbcTemplate jdbc = new JdbcTemplate(dataSource); List<String> results = jdbc.query("select id, name from Things", new RowMapper<String>() { @Override public String mapRow(ResultSet rs, int rowNum) throws SQLException { return rs.getLong("id") + ":" + rs.getString("name"); } }); assertEquals(1, results.size()); assertEquals("1:A", results.get(0)); } } @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:datasource-config.xml") @ActiveProfiles("prod") public static class ProductionDataSourceTest_XMLConfig { @Autowired(required=false) private DataSource dataSource; @Test public void shouldBeEmbeddedDatasource() { // should be null, because there isn't a datasource configured in JNDI assertNull(dataSource); } } }
运行shouldBeEmbeddedDatasource方法,测试通过
总结
以上就是Spring入门实战之Profile详解的内容,更多相关内容请关注PHP中文网(www.php.cn)!