Spring Boot simplifies the development of Spring applications by providing a plethora of annotations that streamline the configuration and setup of applications. In this guide, we’ll dive deep into the most commonly used Spring Boot annotations, exploring their purposes and demonstrating their use with real-time examples.
1. Core Spring Framework Annotations
@SpringBootApplication
Purpose: Serves as a convenience annotation that adds all of the following:
@Configuration :Tags the class as a source of bean definitions for the application context.@EnableAutoConfiguration: Tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings.@ComponentScan: Tells Spring to look for other components, configurations, and services in the specified package, allowing it to find and register your beans.
Example:
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}@Autowired
Purpose: Automatically wires beans in your application context to properties, constructors, or methods.
Example:
@Service
public class MyService {
private final MyRepository repository;
@Autowired
public MyService(MyRepository repository) {
this.repository = repository;
}
}2. Conditional Annotations
@ConditionalOnClass
Purpose: Ensures a bean is only created if a specific class is present on the classpath.
Example:
@Configuration
@ConditionalOnClass(MyClass.class)
public class MyClassConfig {
// Configuration related to MyClass
}@ConditionalOnMissingBean
Purpose: Creates a bean only if a bean of the same type is not already present.
Example:
@Bean
@ConditionalOnMissingBean
public MyService myService() {
return new DefaultMyService();
}3. Property-based Annotations
@Value
Purpose: Injects property values into your beans.
Example:
@Component
public class MyComponent {
@Value("${my.property}")
private String myProperty;
}@ConfigurationProperties
Purpose: Binds and validates external configurations to a configuration class.
Example:
@Component
@ConfigurationProperties(prefix = "my")
public class MyProperties {
private String property;
// getters and setters
}4. Web Development Annotations
@RestController
Purpose: A convenience annotation that combines @Controller and @ResponseBody, which eliminates the need to annotate every request handling method of the controller class with the @ResponseBody annotation.
Example:
@RestController
public class MyController {
@GetMapping("/hello")
public String hello() {
return "Hello World";
}
}@RequestMapping
Purpose: Maps HTTP requests to handler methods of MVC and REST controllers.
Example:
@RestController
public class MyController {
@RequestMapping(value = "/greeting", method = RequestMethod.GET)
public String greeting() {
return "Hello, World";
}
}Conclusion
Spring Boot’s annotations offer a powerful and expressive way of defining how your application behaves and interacts with its environment. From configuring beans and injecting dependencies to controlling your application’s web layer, these annotations streamline development and allow for cleaner, more maintainable code. By leveraging these annotations effectively, developers can significantly reduce boilerplate code and focus on building the unique features of their applications.
This post has touched on a fraction of the annotations available in Spring and Spring Boot, focusing on those most commonly used. For a deeper dive, the official Spring Boot documentation is an invaluable resource, providing detailed information on a wide array of annotations and their uses.
