Java Spring Framework is an open-source and enterprise-level framework used to create production-grade, standalone applications that run on the Java Virtual Machine (JVM). To this end, Java Spring Boot is a tool that simplifies and accelerates the development of web applications and microservices with the Spring Framework. For this, Java Spring Boot leverages three core capabilities – autoconfiguration, an opinionated approach to configuration, and the potential to create standalone applications. The amalgamation of these core features provides a tool that allows developers to set up Spring-based applications with minimal configurations.
Before annotations, the Spring Framework behavior was mostly XML configuration-controlled. However, Spring Boot annotations have dramatically altered how you can configure the behaviors of the Spring Framework.
In this article, we’ll go through some of the basic annotations in the Spring Framework.
What Are Spring Boot Annotations?
Spring Boot annotations are a form of metadata. They are not a part of the application under development per se but provide supplemental data about a program. Annotations have no direct impact on the operation of the code they annotate, nor do they alter the action of the compiled program.
Spring applications require a significant degree of configuration. Spring Boot is an opinionated framework that builds off the Spring Framework. It minimizes the configuration efforts and boilerplate one needs to get started. Spring Boot annotations are the key to gaining control over the Spring Framework, directing the framework, and overriding its defaults when required. These annotations are easy to use and quicker than building the equivalent functionalities from scratch.
Spring Boot Annotations Everyone Should Know
Although Spring Boot works Java, Groovy, and Kotlin, we’ll focus on Java while discussing the important Spring Boot annotations.
1. @Configuration
The @Configuration is used in classes that define beans. An analog of XML configuration file is a class-level annotation used as a source of bean definitions. A @Configuration annotated Java class is a configuration in itself and has methods to configure and instantiate dependencies.
Example:
@Configuration
public class Bus
{
@BeanBus engine()
{
return new Bus();
}
}
2. @Bean
An alternative to the XML <bean> tag, the @Bean annotation is used at the method level to indicate that a method produces a bean to be managed by the Spring container. This annotation works along with @Configuration to create Spring beans. The @Configuration has methods to configure and instantiate dependencies, and such methods are annotated by @Bean.
Example:
@Bean
Public BeanExample beanExample ()
{
return new BeanExample (),
}
3. @ComponentScan
The @ComponentScan annotation is used to scan a package of beans. It is used along with the @Configuration annotation to let Spring know the packages that must be scanned for annotated components.
Example:
@ComponentScan(basePackages = “com.xyz”)
@Configuration
Public class ScanComponent
{
//…
}
4. @Component
The @Component annotation is used on classes to denote a Spring component. It is a class-level annotation that converts the class into Spring bean during auto-scan.
Example:
@Component
Public class Teachers
{
……
}
5. @EnableAutoConfiguration
The @EnableAutoConfiguration annotation is typically placed on the main application class, and it implicitly defines a base search package. Based on classpath settings, various property settings, and other beans, @EnableAutoConfiguration directs Spring Boot to begin adding beans.
6. @SpringBootApplication
The @SpringBootApplication annotation adds three annotations – @Configuration, @EnableAutoConfiguration, and @ComponentScan. It is used on the application class while setting up the Spring Boot project, and the class annotated with @SpringBootApplication is placed in the base package. The @SpringBootApplication does component scanning, but only of the sub-packages.
7. @Repository
The @Repository annotation is used on Java classes that access the database directly. It works as a marker for classes that fulfill the role of Data Access Object or repository.
Example:
@Repository
public class TestRepository
{
public void delete()
{
// persistence code
}
}
8. @Service
It is a class-level annotation that marks a Java class performing a service such as executing business logic, performing calculations, or calling external APIs. A @Service annotation is a special form of the @Component annotation for use in the service layer.
Example:
@Service
public class TestService
{
public void service1()
{
// business code
}
}
9. @Autowired
This annotation implicitly injects object dependency and is applied on fields, constructors, and setter methods. When @Autowired is used on fields, and the values for the fields are passed using the property name, Spring automatically assigns the fields with the passed values.
10. @Controller
The @Controller annotation is used on Java classes that serve as the controller in an application. It allows auto-detecting component classes in the classpath and also auto-registers of bean definitions for them. The @Controller annotation is typically used with @RequestMapping, and the Java classes annotated with @Controller can handle multiple request mappings.
Example:
@Controller
@RequestMapping(“cars”)
public class CarsController
{
@RequestMapping(value= “/{name}”, method= RequestMethod.GET)
public Employee getCarsByName()
{
Return carsTemplate;
}
}
11. @RequestMapping
The @RequestMapping annotation is used at both the method and class level. It serves to map web requests onto specified handler methods and handler classes. When @RequestMapping is used on methods, it gives the URL on which handler methods execution will occur. On the contrary, when the annotation is used at the level of classes, it creates a base URL for which the controller will be used. Hence, each handler method will have its respective request mapping, whereas the class-level request mapping remains the same.
Example:
@Controller
public class FlowersController
{
@RequestMapping (“/red-colour/flowers”)
public String getAllFlowers(Model model)
{
//application code
return “flowerlist”;
}
12. @Qualifier
@Qualifier is used along with @Autowired when more control is needed over the dependency injection process. The @Qualifier annotation may be specified either on method parameters or individual constructor arguments. Confusions usually arise when the developer creates more than one bean of the same type, but only one of them has to be wired with a property. The @Qualifier annotation comes in handy to eliminate these confusions.
Example:
@Component
public class BeanB1 implements BeanInterface {
//
}
@Component
public class BeanB2 implements BeanInterface {
//
}
In the above example, BeanInterface is implemented by the two beans BeanB1 and BeanB2. Now, if BeanA autowires this interface, Spring wouldn’t know which of the two implementations it should inject. You can solve this problem using the @Qualifier annotation. With this annotation in place, Spring will know which of the beans to autowire.
@Component
public class BeanA {
@Autowired
@Qualifier(“beanB2”)
private BeanInterface dependency;
…
}
13. @Value
The @Value annotation is used at the field, method parameter, and constructor parameter levels. It denotes a default value expression for the parameter or field to initialize the property with.
14. @Lazy
The @Lazy annotation is applied to the component classes. At startup, all autowired dependencies are created and configured by default. But the @Lazy annotation can be used if the developer wants to initialize a bean lazily. Thus, the bean gets created and initialized only upon request. The @Lazy annotation can also be used on @Configuration classes, which means that all @Bean methods in that @Configuration will be initiated lazily.
While this list of Java Spring Boot annotations is not exhaustive, it more or less covers the most basic ones that every developer or Java enthusiast should know. After all, Spring Boot has simplified the development of Spring-based applications and is worth knowing.
Master of Science in Data Science from Liverpool John Moores University
If you are an aspiring data scientist, here’s an opportunity to learn from the best. upGrad offers an online Master of Science in Data Science in partnership with Liverpool John Moores University, specially designed for working professionals looking to hone their data science skills and knowledge.
Here are some program highlights at a glance:
- Master’s Degree from LJMU and Executive PGP from IIT Bangalore
- 500+ hours of learning packed with live sessions, case studies, and projects
- Comprehensive coverage of 14+ tools and software
- Three unique specializations
- 360-degree dedicated career assistance
- Peer learning and industry networking
upGrad’s immersive and industry-relevant learning programs have impacted over 500,000 working professionals globally and continue to set high standards in the higher EdTech industry. So, apply today and join the 40,000+ global learner base spread over 85 countries!
Learn data science courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.
![13 Exciting Data Science Project Ideas & Topics for Beginners in US [2024]](/__khugblog-next/image/?url=https%3A%2F%2Fd14b9ctw0m6fid.cloudfront.net%2Fhttps%3A%2F%2F65.0.10.158%2Fblog%2Fwp-content%2Fuploads%2F2019%2F07%2FBlog_FI_July_upGrads-Knowledge-base.png&w=3840&q=75)
