Maison >Java >javaDidacticiel >Explication détaillée du profil pour démarrer avec Spring

Explication détaillée du profil pour démarrer avec Spring

黄舟
黄舟original
2017-03-07 09:54:482008parcourir

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")

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.

另外对于测试,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&#39;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&#39;t a datasource configured in JNDI
 assertNull(dataSource);
 }
 }

}

运行shouldBeEmbeddedDatasource方法,测试通过

总结

 以上就是Spring入门实战之Profile详解的内容,更多相关内容请关注PHP中文网(www.php.cn)!



Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn