Profil Musim Semi

1. Gambaran keseluruhan

Dalam tutorial ini, kami akan memberi tumpuan untuk memperkenalkan Profil pada musim bunga.

Profil adalah ciri utama kerangka kerja - yang memungkinkan kami memetakan kacang kami ke profil yang berbeza - misalnya, dev , test , dan prod .

Kita kemudian dapat mengaktifkan profil yang berbeza di persekitaran yang berbeza untuk hanya butang butang yang kita perlukan.

**2. Gunakan @Profile pada Kacang**

Mari mulakan sederhana dan lihat bagaimana kita boleh membuat kacang tergolong dalam profil tertentu. Kami menggunakan anotasi @Profile - kami memetakan kacang ke profil tertentu ; penjelasan hanya mengambil nama satu (atau beberapa) profil.

Pertimbangkan senario asas: Kami mempunyai kacang yang seharusnya hanya aktif selama pembangunan tetapi tidak digunakan dalam pengeluaran.

Kami mencantumkan kacang itu dengan profil dev , dan ia hanya akan terdapat di dalam bekas semasa pembangunan. Dalam pengeluaran, dev tidak akan aktif:

@Component @Profile("dev") public class DevDatasourceConfig

Sebagai sidenote cepat, nama profil juga boleh diawali dengan operator TIDAK, misalnya ,! Dev , untuk mengecualikannya dari profil.

Contohnya, komponen diaktifkan hanya jika profil dev tidak aktif:

@Component @Profile("!dev") public class DevDatasourceConfig

3. Menyatakan Profil dalam XML

Profil juga boleh dikonfigurasi dalam XML. Thetag mempunyai atribut profil , yang mengambil nilai yang dipisahkan koma dari profil yang berlaku:

4. Tetapkan Profil

Langkah seterusnya adalah mengaktifkan dan menetapkan profil supaya kacang masing-masing didaftarkan di dalam bekas.

Ini dapat dilakukan dengan pelbagai cara, yang akan kita terokai di bahagian berikut.

4.1. Secara Berprogram melalui Antaramuka WebApplicationInitializer

Dalam aplikasi web, WebApplicationInitializer dapat digunakan untuk mengkonfigurasi ServletContext secara terprogram.

Ini juga merupakan lokasi yang sangat berguna untuk menetapkan profil aktif kami secara teratur:

@Configuration public class MyWebApplicationInitializer implements WebApplicationInitializer { @Override public void onStartup(ServletContext servletContext) throws ServletException { servletContext.setInitParameter( "spring.profiles.active", "dev"); } }

4.2. Secara terprogram melalui ConfigureableEnvironment

Kami juga boleh menetapkan profil secara langsung di persekitaran:

@Autowired private ConfigurableEnvironment env; ... env.setActiveProfiles("someProfile");

4.3. Parameter Konteks dalam web.xml

Begitu juga, kita dapat menentukan profil aktif dalam fail web.xml aplikasi web, menggunakan parameter konteks:

 contextConfigLocation /WEB-INF/app-config.xml   spring.profiles.active dev

4.4. Parameter Sistem JVM

Nama profil juga dapat diteruskan melalui parameter sistem JVM. Profil ini akan diaktifkan semasa permulaan aplikasi:

-Dspring.profiles.active=dev

4.5. Pembolehubah Persekitaran

Dalam persekitaran Unix, profil juga dapat diaktifkan melalui pemboleh ubah persekitaran :

export spring_profiles_active=dev

4.6. Profil Maven

Profil spring juga dapat diaktifkan melalui profil Maven, dengan menentukan sifat konfigurasi spring.profiles.active .

Di setiap profil Maven, kita dapat menetapkan sifat spring.profiles.active :

  dev  true   dev    prod  prod

Nilainya akan digunakan untuk menggantikan placeholder @ [dilindungi e-mel] dalam application.properties :

[email protected]@

Sekarang kita perlu mengaktifkan penapisan sumber dalam pom.xml :

   src/main/resources true   ...

dan tambahkan parameter -P untuk menukar profil Maven mana yang akan digunakan:

mvn clean package -Pprod

Arahan ini akan pakej permohonan untuk prod profil. Ini juga menggunakan prod nilai spring.profiles.active untuk aplikasi ini semasa ia sedang berjalan.

**4.7. @ActiveProfile dalam Ujian**

Ujian menjadikannya sangat mudah untuk menentukan profil apa yang aktif menggunakan anotasi @ActiveProfile untuk membolehkan profil tertentu:

@ActiveProfiles("dev")

So far, we've looked at multiple ways of activating profiles. Let's now see which one has priority over the other and what happens if we use more than one, from highest to lowest priority:

Context parameter in web.xml
WebApplicationInitializer
JVM System parameter
Environment variable
Maven profile

5. The Default Profile

Any bean that does not specify a profile belongs to the default profile.

Spring also provides a way to set the default profile when no other profile is active — by using the spring.profiles.default property.

6. Get Active Profiles

Spring's active profiles drive the behavior of the @Profile annotation for enabling/disabling beans. However, we may also wish to access the list of active profiles programmatically.

We have two ways to do it, using Environment or spring.active.profile.

6.1. Using Environment

We can access the active profiles from the Environment object by injecting it:

public class ProfileManager { @Autowired    private Environment environment;     public void getActiveProfiles() {         for (String profileName : environment.getActiveProfiles()) {             System.out.println("Currently active profile - " + profileName);         }       } }

6.2. Using spring.active.profile

Alternatively, we could access the profiles by injecting the property spring.profiles.active:

@Value("${spring.profiles.active}") private String activeProfile;

Here, our activeProfile variable will contain the name of the profile that is currently active, and if there are several, it'll contain their names separated by a comma.

However, we should consider what would happen if there is no active profile at all. With our code above, the absence of an active profile would prevent the application context from being created. This would result in an IllegalArgumentException owing to the missing placeholder for injecting into the variable.

In order to avoid this, we can define a default value:

@Value("${spring.profiles.active:}") private String activeProfile;

Now, if no profiles are active, our activeProfile will just contain an empty string.

And if we want to access the list of them just like in the previous example, we can do it by splitting the activeProfile variable:

public class ProfileManager { @Value("${spring.profiles.active:}") private String activeProfiles; public String getActiveProfiles() { for (String profileName : activeProfiles.split(",")) { System.out.println("Currently active profile - " + profileName); } } }

7. Example: Separate Data Source Configurations Using Profiles

Now that the basics are out of the way, let's take a look at a real example.

Consider a scenario where we have to maintain the data source configuration for both the development and production environments.

Let's create a common interface DatasourceConfig that needs to be implemented by both data source implementations:

public interface DatasourceConfig { public void setup(); }

Following is the configuration for the development environment:

@Component @Profile("dev") public class DevDatasourceConfig implements DatasourceConfig { @Override public void setup() { System.out.println("Setting up datasource for DEV environment. "); } }

And configuration for the production environment:

@Component @Profile("production") public class ProductionDatasourceConfig implements DatasourceConfig { @Override public void setup() { System.out.println("Setting up datasource for PRODUCTION environment. "); } }

Now let's create a test and inject our DatasourceConfig interface; depending on the active profile, Spring will inject DevDatasourceConfig or ProductionDatasourceConfig bean:

public class SpringProfilesWithMavenPropertiesIntegrationTest { @Autowired DatasourceConfig datasourceConfig; public void setupDatasource() { datasourceConfig.setup(); } }

When the dev profile is active, Spring injects DevDatasourceConfig object, and when calling then setup() method, the following is the output:

Setting up datasource for DEV environment.

8. Profiles in Spring Boot

Spring Boot supports all the profile configuration outlined so far, with a few additional features.

The initialization parameter spring.profiles.active, introduced in Section 4, can also be set up as a property in Spring Boot to define currently active profiles. This is a standard property that Spring Boot will pick up automatically:

spring.profiles.active=dev

To set profiles programmatically, we can also use the SpringApplication class:

SpringApplication.setAdditionalProfiles("dev");

To set profiles using Maven in Spring Boot, we can specify profile names under spring-boot-maven-plugin in pom.xml:

  org.springframework.boot spring-boot-maven-plugin   dev    ...

and execute the Spring Boot-specific Maven goal:

mvn spring-boot:run

But the most important profiles-related feature that Spring Boot brings is profile-specific properties files. These have to be named in the format application-{profile}.properties.

Spring Boot will automatically load the properties in an application.properties file for all profiles, and the ones in profile-specific .properties files only for the specified profile.

For example, we can configure different data sources for dev and production profiles by using two files named application-dev.properties and application-production.properties:

In the application-production.properties file, we can set up a MySql data source:

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/db spring.datasource.username=root spring.datasource.password=root

Then we can configure the same properties for the dev profile in the application-dev.properties file, to use an in-memory H2 database:

spring.datasource.driver-class-name=org.h2.Driver spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1 spring.datasource.username=sa spring.datasource.password=sa

In this way, we can easily provide different configurations for different environments.

9. Conclusion

Dalam artikel ini, kami membincangkan bagaimana menentukan profil pada kacang dan bagaimana mengaktifkan profil yang betul dalam aplikasi kami.

Akhirnya, kami mengesahkan pemahaman kami mengenai profil dengan contoh yang ringkas tetapi nyata.

Pelaksanaan tutorial ini boleh didapati dalam projek GitHub.