When working with the Spring Boot framework, annotations play a crucial role in providing metadata and configuration information for your applications. In this blog, we'll dive into some of the most important Spring Boot annotations and their applications. 🚀

Core Spring Framework Annotations

Required 🛠️

The @Required annotation is applied to bean setter methods. It indicates that the annotated bean must be populated with the required property at configuration time. If not, it throws an exception (BeanInitializationException). For example:

public class Machine {
    private Integer cost;
    @Required
    public void setCost(Integer cost) {
        this cost = cost;
    }
}

Autowired 🤝

Spring provides annotation-based auto-wiring with @Autowired. It's used to autowire Spring beans on setter methods, instance variables, and constructors. When you use @Autowired, the Spring container auto-wires the bean by matching data types. For example:

@Component
public class Customer {
    private Person person;
    @Autowired
    public Customer(Person person) {
        this person = person;
    }
}

Configuration ⚙️

The @Configuration annotation is used at the class level. Classes annotated with @Configuration are used by Spring Containers as a source of bean definitions. For example:

@Configuration
public class Vehicle {
    @Bean
    public Vehicle engine() {
        return new Vehicle();
    }
}

ComponentScan 📡

@ComponentScan is used when you want to scan a package for beans. It is often used in conjunction with the @Configuration annotation and you can specify base packages to scan for Spring components. For example:

@ComponentScan(basePackages = "com.javatpoint")
@Configuration
public class ScanComponent {
    // ...
}

Bean ☕

The @Bean annotation is used at the method level. It is an alternative to the XML <bean> tag and tells the method to produce a bean managed by the Spring Container. For example:

@Bean
public BeanExample beanExample() {
    return new BeanExample();
}

Spring Framework Stereotype Annotations

Component 🧩

@Component is a class-level annotation used to mark a Java class as a bean. Classes annotated with @Component are discovered during the classpath scanning and configured as Spring Beans. For example:

@Component
public class Student {
    // ...
}

Controller 🎮

@Controller is a specialization of @Component and is often used to serve web pages. It marks a class as a web request handler and is typically used with the @RequestMapping annotation. For example:

@Controller
@RequestMapping("books")
public class BooksController {
    // ...
}

Service 🛠️

The @Service annotation is used at the class level to indicate that the class contains business logic. For example:

@Service
public class TestService {
    public void service1() {
        // business code
    }
}

Repository 🗄️

@Repository is a class-level annotation commonly used for Data Access Objects (DAOs) that access databases directly. For example:

@Repository
public class TestRepository {
    public void delete() {
        // persistence code
    }
}

Spring Boot Annotations

EnableAutoConfiguration and SpringBootApplication🚗

• @EnableAutoConfiguration auto-configures beans present in the classpath.

• @SpringBootApplication combines @EnableAutoConfiguration, @ComponentScan, and @Configuration.

Spring MVC and REST Annotations

RequestMapping 🌐

@RequestMapping is used to map web requests and has various optional elements like consumes, header, method, name, params, path, produces, and value. It can be used with both classes and methods.

HTTP Request Method Annotations 🌐

• @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, and @PatchMapping are used to map HTTP request methods to specific handler methods.

Request and Response Annotations 📜

• @RequestBody binds an HTTP request to a method parameter.

• @ResponseBody binds the method return value to the response body.

• @PathVariable extracts values from the URI.

• @RequestParam extracts query parameters from the URL.

• @RequestHeader gets details about HTTP request headers.

RestController 🎮

@RestController combines @Controller and @ResponseBody annotations, eliminating the need to annotate each method with @ResponseBody.

RequestAttribute 🏷️

@RequestAttribute binds a method parameter to a request attribute.

With this guide, you have a solid understanding of key Spring Boot annotations and their applications. Annotations simplify the configuration and development of Spring Boot applications, making your journey into Spring Boot development smoother and more efficient. Happy coding! 🌈