Spring Boot Annotations

June 01, 2018 0 Comments

1. Overview


Spring Boot made configuring Spring easier with its auto-configuration feature.


In this quick tutorial, we’ll explore the annotations from the org.springframework.boot.autoconfigure and org.springframework.boot.autoconfigure.condition packages.


2. @SpringBootApplication


We use this annotation to mark the main class of a Spring Boot application:


@SpringBootApplication
class VehicleFactoryApplication {

public static void main(String[] args) {
SpringApplication.run(VehicleFactoryApplication.class, args);
}
}

@SpringBootApplication encapsulates @Configuration, @EnableAutoConfiguration, and @ComponentScan annotations with their default attributes.


3. @EnableAutoConfiguration


@EnableAutoConfiguration, as its name says, enables auto-configuration. It means that Spring Boot looks for auto-configuration beans on its classpath and automatically applies them.


Note, that we have to use this annotation with @Configuration:


@Configuration
@EnableAutoConfiguration
class VehicleFactoryConfig {}

4. Auto-Configuration Conditions


Usually, when we write our custom auto-configurations, we want Spring to use them conditionally. We can achieve this with the annotations in this section.


We can place the annotations in this section on @Configuration classes or @Bean methods.


In the next sections, we’ll only introduce the basic concept behind each condition. For further information, please visit this article.


4.1. @ConditionalOnClass and @ConditionalOnMissingClass


Using these conditions, Spring will only use the marked auto-configuration bean if the class in the annotation’s argument is present/absent:


@Configuration
@ConditionalOnClass(DataSource.class)
class MySQLAutoconfiguration {
//...
}

4.2. @ConditionalOnBean and @ConditionalOnMissingBean


We can use these annotations when we want to define conditions based on the presence or absence of a specific bean:


@Bean
@ConditionalOnBean(name = "dataSource")
LocalContainerEntityManagerFactoryBean entityManagerFactory() {
// ...
}

4.3. @ConditionalOnProperty


With this annotation, we can make conditions on the values of properties:


@Bean
@ConditionalOnProperty(
name = "usemysql",
havingValue = "local"
)
DataSource dataSource() {
// ...
}

4.4. @ConditionalOnResource


We can make Spring to use a definition only when a specific resource is present:


@ConditionalOnResource(resources = "classpath:mysql.properties")
Properties additionalProperties() {
// ...
}

4.5. @ConditionalOnWebApplication and @ConditionalOnNotWebApplication


With these annotations, we can create conditions based on if the current application is or isn’t a web application:


@ConditionalOnWebApplication
HealthCheckController healthCheckController() {
// ...
}

4.6. @ConditionalExpression


We can use this annotation in more complex situations. Spring will use the marked definition when the SpEL expression is evaluated to true:


@Bean
@ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}")
DataSource dataSource() {
// ...
}

4.7. @Conditional


For even more complex conditions, we can create a class evaluating the custom condition. We tell Spring to use this custom condition with @Conditional:


@Conditional(HibernateCondition.class)
Properties additionalProperties() {
//...
}

5. Conclusion


In this article, we saw an overview of how can we fine-tune the auto-configuration process and provide conditions for custom auto-configuration beans.


As usual, the examples are available over on GitHub.




Source: Java Baeldung

Unknown

Some say he’s half man half fish, others say he’s more of a seventy/thirty split. Either way he’s a fishy bastard. Google

0 comments:

Hot-product

Best Watch Store

Popular Posts

Contact Form

Name

Email *

Message *