In Spring what is the difference between @Profile and @ActiveProfiles

Question

What is the difference between using @Profile and @ActiveProfiles on a Spring Test configuration

@Configuration
@EnableRetry
@ActiveProfiles("unittest") 
static class ContextConfiguration {

and

@Configuration
@EnableRetry
@Profile("unittest") 
static class ContextConfiguration {

`@ActiveProfiles` is part of `org.springframework.test`, Im assuming its used to loading profiles during testing. `@Profile` is used for defining/naming profile specific configurations. I've never used `@ActiveProfiles` so this is just my logical guess. — Jason White, May 18 '17 at 19:26
I came across this answer here which seems to generally answer my question http://stackoverflow.com/a/27216503/277023 — kellyfj, May 18 '17 at 19:35
Even if you aren't using `@Profile`, `@ActiveProfiles("test")` can be useful to make `src\test\resources\application-test.properties` active in JUnit tests. Note that eclipse 'Run As->JUnit test' behaves differently than `mvn test` as explained here: https://stackoverflow.com/a/60296719/4505142 — Darren Parker, Aug 04 '22 at 14:30

score 29 · Answer 1 · edited Sep 10 '18 at 10:57

Spring Profiles provide a way to segregate parts of your application configuration.

Any @Component or @Configuration can be marked with @Profile to limit when it is loaded which means that component or configuration will be loaded in the application context only when the active profiles is same as the profile mapped to a component.

To mark a profile active, spring.profiles.active property must be set in application.properties or given as an VM argument as -Dspring.profiles.active=dev

While writing Junit, you would want to activate some profile so as to load the required configuration or Component. Same can be achieved by using @ActiveProfile annotation.

Consider a configuration class which is mapped to profile dev

@Configuration
@Profile("dev")
public class DataSourceConfig {
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost/test");
        ds.setUsername("root");
        ds.setPassword("mnrpass");
        return ds;
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource());
    }
}

Consider a configuration class which is mapped to profile prod

@Configuration
@Profile("prod")
public class DataSourceConfig {
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:oracle://xxx.xxx.xx.xxx/prod");
        ds.setUsername("dbuser");
        ds.setPassword("prodPass123");
        return ds;
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource());
    }
}

So, if you want to run your junit test cases in dev profile then you have to use the @ActiveProfile('dev') annotation. This will load the DataSourceConfig bean defined in dev profile.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@ActiveProfiles("dev")
public class Tests{

    // Junit Test cases will use the 'dev' profile DataSource Configuration

}

Conclusion

@Profile is used to map a class to a profile

@ActiveProfile is used to activate a particular profile(s) during junit test class execution

cse · Accepted Answer · 2021-05-23T16:28:33.170

In short, @Profile defines a profile like a Debug profile and a Production profile etc... However @ActiveProfiles comes into picture in case of an ApplicationContext and defines which profiles should be active if respective ApplicationContext is being used.

As mentioned in JavaDoc of Spring official website:

@Profile

A profile is a named logical grouping that may be activated programmatically via ConfigurableEnvironment.setActiveProfiles(java.lang.String...) or declaratively by setting the spring.profiles.active property as a JVM system property, as an environment variable, or as a Servlet context parameter in web.xml for web applications. Profiles may also be activated declaratively in integration tests via the @ActiveProfiles annotation.

@ActiveProfiles

ActiveProfiles is a class-level annotation that is used to declare which active bean definition profiles should be used when loading an ApplicationContext for test classes.

Also, you can see here for more information about @Profile

Mahozad · Answer 3 · 2018-07-18T12:14:21.147

Any @Component or @Configuration can be marked with @Profile to limit when it is loaded.

You define @Profile for your:

classes -directly or indirectly- annotated with @Component, including @Configuration classes
methods annotated with @Bean

Then while testing, you choose which profile(s) you want by specifying them in @ActiveProfiles.

ActiveProfiles is a class-level annotation that is used to declare which active bean definition profiles should be used when loading an ApplicationContext for test classes.

It has no effect if used outside of the test context.

Summary

You assign profile to your components with @Profile; while testing select them with @ActiveProfiles, while developing select them with spring.profiles.active property.

score 3 · Answer 4 · answered Sep 10 '18 at 15:32

@Profile is used to define different @Bean definitions for different contexts, e.g:

public class BeanConfiguration {
    @Bean
    @Profile({"local", "dev", "ci-dev", "homolog"})
    public SomeHttpClientBean adyenClientFactorySandbox() {
        return SomeHttpClientBean.builder()
            .url("https://test.example.com")
            .build();
    }

    @Bean
    @Profile("prod")
    public SomeHttpClientBean adyenClientFactorySandbox() {
        return SomeHttpClientBean.builder()
            .url("https://production.example.com")
            .build();
    }
}

Once you have that configuration, when starting your application, all you need to do is set which profile is active, either by spring.profiles.active property or by annotating a class:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
@ActiveProfiles("ci-dev")
public class SpringBootTestBase {
    @Test
    ...
}

score 2 · Answer 5 · answered Sep 06 '18 at 08:25

with @Profile annotation you set condition to your bean definition, which impacts create or not create this bean in your spring context depending on current active profiles. Example from JavaDoc:

@Profile({"p1", "!p2"} - registration will occur if profile 'p1' is active or if profile 'p2' is not active.
with @ActiveProfiles you set current active profiles. Example:

@ActiveProfiles({"p2","p3"}) bean with annotation @Profile({"p1", "!p2"} will not be created.

@ActiveProfiles({"p3"}) bean with annotation @Profile({"p1", "!p2"} will be created.

@ActiveProfiles({"p1"}) bean with annotation @Profile({"p1", "!p2"} will be created.

score 2 · Answer 6 · answered Sep 10 '18 at 21:23

@Profile is used when declaring a bean or configuration. @Profile declares which profile the bean or configuration belongs to.

@ActiveProfiles is used only from tests that are consuming a bean or configuration to enable one or more profiles.

When @ActiveProfiles is specified, it causes the Spring Context to check whether a bean or configuration is annotated with @Profile. If so, that bean or configuration is only loaded if the profile in @ActiveProfiles matches the profile rule in the bean's @Profile annotation.

In Spring what is the difference between @Profile and @ActiveProfiles

6 Answers6

Summary