Spring Boot Annotations

@SpringBootApplication

We use this annotation to mark the main class of a Spring Boot application:
1
2
3
4
5
6
7
@SpringBootApplication
class VehicleFactoryApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(VehicleFactoryApplication.class, args);
    }
}
@SpringBootApplication encapsulates @Configuration, @EnableAutoConfiguration, and @ComponentScanannotations with their default attributes.

@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:
1
2
3
@Configuration
@EnableAutoConfiguration
class VehicleFactoryConfig {}

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.

@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:
1
2
3
4
5
@Configuration
@ConditionalOnClass(DataSource.class)
class MySQLAutoconfiguration {
    //...
}

@ConditionalOnBean and @ConditionalOnMissingBean

We can use these annotations when we want to define conditions based on the presence or absence of a specific bean:
1
2
3
4
5
@Bean
@ConditionalOnBean(name = "dataSource")
LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    // ...
}

@ConditionalOnProperty

With this annotation, we can make conditions on the values of properties:
1
2
3
4
5
6
7
8
@Bean
@ConditionalOnProperty(
    name = "usemysql",
    havingValue = "local"
)
DataSource dataSource() {
    // ...
}

@ConditionalOnResource

We can make Spring to use a definition only when a specific resource is present:
1
2
3
4
@ConditionalOnResource(resources = "classpath:mysql.properties")
Properties additionalProperties() {
    // ...
}

@ConditionalOnWebApplication and @ConditionalOnNotWebApplication

With these annotations, we can create conditions based on if the current application is or isn’t a web application:
1
2
3
4
@ConditionalOnWebApplication
HealthCheckController healthCheckController() {
    // ...
}

@ConditionalExpression

We can use this annotation in more complex situations. Spring will use the marked definition when the SpEL expression is evaluated to true:
1
2
3
4
5
@Bean
@ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}")
DataSource dataSource() {
    // ...
}

@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:
1
2
3
4
@Conditional(HibernateCondition.class)
Properties additionalProperties() {
    //...
}

Comments

Post a Comment

Popular posts from this blog

gsutil Vs Storage Transfer Service Vs Transfer Appliance

When transferring data from an on-premiss location, use gsutil When transferring data from another cloud storage provider, use storage transfer service gsutil is a Python application that lets you access Cloud Storage from the command line. You can use gsutil to do a wide range of bucket and object management tasks, including: Creating and deleting buckets. Uploading, downloading, and deleting objects. Listing buckets and objects. Moving, copying, and renaming objects. Editing object and bucket ACLs. gsutil performs all operations, including uploads and downloads, using HTTPS and transport-layer security (TLS). For a complete list of guides to completing tasks with gsutil, see  Cloud Storage How-to Guides . Storage Transfer Service is a product that enables you to: Move or backup data to a Cloud Storage bucket either from other cloud storage providers or from your  on-premises  storage. Move data from one Cloud Storage bucket to another, so that it is available to differe...
Read more

Algorithms Introduction

Algorithms vs Program  Algorithms are written at design time. It requires to have strong domain knowledge. It can be written any language or sudo code. No hardware requires and we should analyse the algorithms. Data type of input is not decided at algorithms time. Program is written at implementation time. It requires to be a good programmer. It can be written in any programming language. Hardware and OS required. Program should be tested. Data type is decided at this point of time. Characteristics of Algorithm 1. Input : May take 0 or more input 2. Output : Must provide some useful result 3. Definiteness : Every statement should be definite and clear 4. Finiteness : Algorithms must terminate at some point of time. That means duration of algorithms must be finite 5. Effectiveness : It should have effective statements. Classes of functions 1. Constant time – O (1)  2. Logarithmic time – O (log n)  3.  Linear time – O (n) 4. Quadratic time – O (n^2)  5. Cubic time...
Read more