Was ist ein Federprofil? Vereinfacht gesagt handelt es sich bei einem Profil um eine Reihe von Konfigurationen. Verschiedene Profile bieten unterschiedliche Kombinationen von Konfigurationen. Wenn das Programm ausgeführt wird, können Sie auswählen, welche Profile zur Anpassung an die Umgebung verwendet werden sollen. Im folgenden Artikel werden hauptsächlich relevante Informationen zur tatsächlichen Implementierung von Profile in Spring vorgestellt. Freunde in Not können sich darauf beziehen.
Vorwort
Die Profilfunktion im Frühjahr gibt es tatsächlich schon seit Frühjahr 3.1. Man kann verstehen, dass wir uns im Frühjahr befinden Container Der logische Gruppenname der definierten Beans. Nur wenn diese Profile aktiviert sind, werden die den Profilen 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();
}Es wird hier definiert. Eine Things-Tabelle enthält zwei Felder
Zusätzlich zur Schemadatei müssen Testdaten auch über test-data.sql geladen werdencreate table Things ( id identity, name varchar(100) );
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')
Markieren Sie die EmbedderDataSource-Bean bis , die im Entwickler erstellt werden soll Umweltbohnen.
Hinweis: 1. @Profile wird auf Klassenebene geladen. Wenn das Entwicklerprofil 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();
}
}@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();
}
}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
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 gestartet werden muss und die entsprechenden Bohnen zubereiten.另外对于测试，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）！
