Introduction to Spring Boot Annotations
Spring boot is an open-source framework which is used to create production-grade and stand-alone application. Spring boot provides us many different annotations that help to configure many things for our application. Annotations are something that provides us metadata about the program. Annotations are generally providing additional information. So spring boot made configuration easy for us by providing annotations.
Different Annotations of Spring Boot
Spring boot provides so many different annotations which are as follows:
1. @SpringBootApplication
This application is the combination of so many different annotations which includes:
- @Configuration
- @ComponentScan
- @EnableAutoConfiguration
This annotation is used in the main class of our application it is the entry point of our application as well.
Example:
@SpringBootApplication
class SpringBootDemo {
public static void main(String[] args) {
SpringApplication.run(SpringBootDemo.class, args);
}
}
2. @EnableAutoConfiguration
This annotation is used to enable auto-configuration in our application. If a class contains this annotation then spring boot automatically looks for all beans on the classpath and automatically configures them.
4.5 (3,351 ratings)
View Course
Example:
@Configuration
@EnableAutoConfiguration
class DemoConfigure {}
3. Auto-Configuration Conditions
We have different conditions for auto configurations. So when we write our own or we can say custom configuration but we want spring to use them on some condition so in order to achieve this we can use this condition annotation.
- @ConditionalOnMissingClass and @ConditionalOnClass: Now we can pass the class object as an argument in the annotation. Spring will only use this auto-configuration bean if we pass the argument in the annotation.
Example:
@Configuration
@ConditionalOnClass(DataSource.class)
class SqlConnectionDemo {
//...
}
- @ConditionalOnMissingBean and @ConditionalOnBean: We can also apply condition on the presence or absence of a bean, which means we can pass the name of the bean inside the annotations.
Example:
@Bean
@ConditionalOnBean(name = "dataSource")
LocalContainerEntityManagerFactoryBean entityManagerFactory() {
// ...
}
- @ConditionalOnProperty: We can also apply condition on the value. So by using this annotation, we can be able to do so.
Example:
@Bean
@ConditionalOnProperty(
name = "username",
havingValue = "some-value"
)
DataSource dataSource() {
// ...
}
- @ConditionalOnResource: We can also apply condition by checking if the resource is available or not.
Example:
@ConditionalOnResource(resources = "classpath:mysql.properties")
Properties additionalProperties() {
// ...
}
- @ConditionalOnNotWebApplication and @ConditionalOnWebApplication: We can also apply conditions on the application level we can apply them on checking whether they are web application or not.
Example:
@ConditionalOnWebApplication
HealthDemoController healthDemoController() {
// ...
}
- @ConditionalExpression: We use this annotation condition related to SQEL expression. This condition comes under complex conditions.
Example:
@Bean
@ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}")
DataSource dataSource() {
// ...
}
- @Conditional: If you want to create some more and more complex condition then we can create a class which will turn to evaluate the custom condition.
Example:
@Conditional(HibernateCondition.class)
Properties additionalProperties() {
//...
4. @Required
The field which is using this annotation must be configured at the time of configuration with all the required properties, otherwise, it will throw an exception saying BeanInitilizationException. This annotation can be applied on the setter method.
Example:
public class Demo
{
private Integer costDemo;
@Required
public void setcostDemo(Integer costDemo)
{
this.costDemo = costDemo;
}
public Integer getcostDemo()
{
return costDemo;
}
}
5. @Autowired
This annotation can be used on the constructor, setter methods and instance variable. Most of the time it is used on the instance variable. when we use this annotation then spring is responsible to create the instance of that variable, it basically manages the whole life cycle of the object. The whole thing is managed by the spring container.
Example:
@Component
public class AutoDemo
{
private Demo demo;
@Autowired
public AutoDemo(Demo demo)
{
this.demo=demo;
}
}
6. @Configuration
This annotation is used at the class level. Those classes are used by the spring container which is annotated with @Configuration for the source of beans definition.
Example:
@Configuration
public class Demo
{
@Bean
Demo engine()
{
return new Demo();
}
}
7. @ComponentScan
This annotation is used with one another annotation i.e. @Configuration basically we use this annotation to scan the packages of our application for the beans. Here we also pass the name of our base packages for scanning purposes of our spring components.
Example:
@ComponentScan(basePackages = "com.jdemo.annotation")
@Configuration
public class DemoSacn
{
// ...
}
8. @Bean
This annotation is used to provide the bean which is going to manage by the spring container its whole life cycle will depend upon the spring container i.e. initialization, creation, destroy, etc. This annotation i.e. @Bean is the alternative of the XML tag. We can apply it to the method level.
Example:
@Bean
public Demo beanExampleDemo()
{
return new Demo();
}
Spring MVC Annotations
@RequestMapping: This annotation is used to map all web requests to the backend. We can use this annotation at the class level as well as on the method level. It also contains some optional elements like path, value, consumes, produces, header, name, params, etc.
Example:
@Controller
public class DemoOCntroller
{
@RequestMapping("/demo/app/")
public String getAll(Model model)
{
//application code goes here
return "hello world ";
}
MVC uses so many different annotations to handle all type of request from the user for which we have different annotations which are as follows:
- @GetMapping: It handles all the GET method.
- @PostMapping: Handles the POST method.
- @PutMapping: Map the HTTP PUT method.
- @DeleteMapping: Handles HTTP DELETE method.
- @PatchMapping: Handles HTTP PATCH method.
- @RequestBody: Used to send the object.
- @ResponseBody: Return the object in the form of JSON or XML.
- @PathVariable: Pass value in URI.
- @RequestParam: Used to extract the query parameter from the URL.
- @RequestHeader: Provide information about the request header.
- @RestController: This annotation is used at the class level which contains the name attribute with the base url for the class.
- @RequestAttribute: Binds parameter with the request.
Conclusion
Spring boot makes the auto-configuration very much easy with these annotations. It also combines various previous annotations into one to avoid a lot of code. All the configuration is managed by the spring container so developers also need not worry about this.
Recommended Articles
This is a guide to Spring Boot Annotations. Here we discuss the introduction, spring MVC annotations and different Annotations of Spring Boot. You may also have a look at the following articles to learn more –
