EDUCBA Logo

EDUCBA

MENUMENU
  • Explore
    • EDUCBA Pro
    • PRO Bundles
    • Featured Skills
    • New & Trending
    • Fresh Entries
    • Finance
    • Data Science
    • Programming and Dev
    • Excel
    • Marketing
    • HR
    • PDP
    • VFX and Design
    • Project Management
    • Exam Prep
    • All Courses
  • Blog
  • Enterprise
  • Free Courses
  • Log in
  • Sign Up
Home Software Development Software Development Tutorials Spring Tutorial Spring Boot Annotations
 

Spring Boot Annotations

Shalu Sharma
Article byShalu Sharma
EDUCBA
Reviewed byRavi Rathore

Updated July 6, 2023

Spring Boot Annotations

 

 

Introduction to Spring Boot Annotations

Spring boot is an open-source framework used to create production-grade and stand-alone applications. Spring boot provides many annotations that help configure many things for our application. Annotations are something that gives us metadata about the program. In addition, annotations are generally providing additional information. So spring boot made configuration easy for us by providing annotations.

Watch our Demo Courses and Videos

Valuation, Hadoop, Excel, Mobile Apps, Web Development & many more.

Different Annotations of Spring Boot

Spring boot provides so many different annotations, which are as follows:

different annotations

1. @SpringBootApplication

This application is the combination of so many different annotations, which include:

  • @Configuration
  • @ComponentScan
  • @EnableAutoConfiguration

This annotation is used in our application’s main class; it is our application’s entry point 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, Spring Boot automatically looks for all beans on the classpath and automatically configures them.

Example:

@Configuration
@EnableAutoConfiguration
class DemoConfigure {}

3. Auto-Configuration Conditions

We have different conditions for auto configurations. So when we write our own or custom configuration, but we want Spring to use them on some condition, we can use this condition annotation to achieve this.

  •  @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 a 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 conditions 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 conditions 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 use them to check whether they are web applications or not.

Example:

@ConditionalOnWebApplication
HealthDemoController healthDemoController() {
// ...
}
  • @ConditionalExpression: We use this annotation condition related to the SQL expression. This condition comes under complex conditions.

Example:

@Bean
@ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}")
DataSource dataSource() {
// ...
}
  • @Conditional: If you want to create more complex conditions, we can create a class to evaluate the custom condition.

Example:

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

4. @Required

The field using this annotation must be configured with all the required properties at the time of configuration; otherwise, it will throw an exception saying BeanInitilizationException. This annotation can be applied to 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 variables. Most of the time, it is used on the instance variable. When we use this annotation, Spring is responsible for creating the instance of that variable; it manages the whole life cycle of the object. The spring container contains the whole thing.

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. The Spring container uses classes annotated with @Configuration as the source of bean definitions.

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

The Spring container uses this annotation to designate the bean that it will manage; its whole life cycle will depend upon the spring container, i.e., initialization, creation, destroy, etc. This annotation, i.e., @Bean, is the alternative to 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 maps all web requests to the backend. We can use this annotation at the class level as well as at the method level. It also contains 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 types of requests from the user for which we have different annotations, which are as follows:

  • @GetMapping: It takes all the GET methods.
  • @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: The annotation at the class level contains the name attribute, which specifies 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 previous annotations to avoid a lot of code. The spring container manages all the configuration, so developers 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 –

  1. Spring Boot DevTools
  2. Spring Boot Actuator
  3. What is Spring Boot?
  4. Spring Boot Starter Web

Primary Sidebar

Footer

Follow us!
  • EDUCBA FacebookEDUCBA TwitterEDUCBA LinkedINEDUCBA Instagram
  • EDUCBA YoutubeEDUCBA CourseraEDUCBA Udemy
APPS
EDUCBA Android AppEDUCBA iOS App
Blog
  • Blog
  • Free Tutorials
  • About us
  • Contact us
  • Log in
Courses
  • Enterprise Solutions
  • Free Courses
  • Explore Programs
  • All Courses
  • All in One Bundles
  • Sign up
Email
  • [email protected]

ISO 10004:2018 & ISO 9001:2015 Certified

© 2025 - EDUCBA. ALL RIGHTS RESERVED. THE CERTIFICATION NAMES ARE THE TRADEMARKS OF THEIR RESPECTIVE OWNERS.

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
Loading . . .
Quiz
Question:

Answer:

Quiz Result
Total QuestionsCorrect AnswersWrong AnswersPercentage

Explore 1000+ varieties of Mock tests View more

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA
Free Software Development Course

Web development, programming languages, Software testing & others

By continuing above step, you agree to our Terms of Use and Privacy Policy.
*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you

EDUCBA Login

Forgot Password?

🚀 Limited Time Offer! - 🎁 ENROLL NOW