Back to: Spring Framework Tutorials

Spring Framework Annotations Autowiring

In this article, I am going to discuss Spring Framework Annotations Autowiring with Examples. Please read our previous article, where we discussed Spring Framework Constructor Autowiring.

What are Annotations Autowiring in Spring Framework?

Annotations Autowiring in Spring Framework are a powerful feature that allows developers to annotate classes, methods, fields, and other program elements with metadata, which is used by the Spring Framework to provide additional functionality and configuration. Annotations provide a concise and declarative way to specify how components should behave and interact with the Spring container.

In Spring, annotations play a crucial role in defining and configuring various aspects of the application. Here are some commonly used annotations in Spring:

@Autowired

• This annotation is a key annotation in the Spring framework used for automatic dependency injection. It allows Spring to automatically wire or inject the dependencies into the annotated fields, constructors, or methods of a Spring-managed bean.
• When you annotate a field, constructor, or method with @Autowired, Spring will look for a matching bean of the required type in its container and inject it at runtime. It eliminates the need for explicit manual wiring of dependencies, making the code more concise and less error-prone.
• This annotation can also be used with setter methods and fields. When applied to a setter method, Spring will invoke the method and pass the required dependency. When applied to a field, Spring directly injects the dependency into the field.
• It’s worth noting that this annotation is highly flexible and supports various scenarios, such as multiple dependencies, optional dependencies, and more. Additionally, you can use @Autowired in conjunction with other annotations like @Qualifier to provide more control over the dependency resolution process.
• In recent versions of Spring, the @Autowired annotation also supports constructor injection by default. It is considered a best practice to use constructor injection whenever possible, as it ensures that the dependencies are immutable and promotes better testability.

Overall, the @Autowired annotation simplifies the process of dependency injection in Spring, reducing manual configuration and making the code more concise and readable. It plays a crucial role in achieving loose coupling and facilitating the Inversion of Control Principle in Spring applications.

@Qualifier

• This annotation is used in Spring to disambiguate dependencies when multiple beans of the same type are present in the container. It works in conjunction with the @Autowired annotation to specify the specific bean that should be injected.
• When multiple beans of the same type are available, Spring may encounter ambiguity while resolving dependencies. The @Qualifier annotation helps resolve this ambiguity by specifying the bean name or a custom qualifier value.
• By utilizing the @Qualifier annotation, you can resolve ambiguity and precisely specify which bean should be injected when multiple beans of the same type exist in the Spring container. It provides fine-grained control over the dependency resolution process.

Annotations in Spring greatly simplify the configuration process and enhance the readability of the code. They provide a concise and declarative way to express the desired behavior and configuration of components. With annotations, developers can focus on the core logic of their application while leveraging the power and flexibility of the Spring framework.

Annotations also enable developers to write cleaner and more maintainable code by reducing the need for XML-based configuration. They promote convention over configuration and help in achieving a more modular and testable codebase.

It’s important to note that annotations are processed by the Spring container at runtime, allowing for dynamic behavior and adaptability. Spring leverages reflection and runtime introspection to interpret the annotations and apply the necessary configurations and behaviors accordingly.

Overall, annotations are a fundamental aspect of Spring development, enabling developers to express intent, configure components, and leverage the rich features and capabilities of the Spring framework. They contribute to the overall productivity and maintainability of Spring applications.

Benefits of Annotations Autowiring in Spring Framework

Annotations in Spring offer several benefits that enhance the development experience and make the configuration and management of Spring applications more efficient. Benefits of using annotations in Spring Framework:

1. Simplicity and Readability: Annotations provide a concise and declarative way to express configuration and behavior. They make the code more readable by reducing the need for verbose XML configuration. Annotations allow developers to focus on the core logic of their code while conveying important information about the components and their relationships.
2. Reduced Configuration: Annotations eliminate the need for explicit XML configuration in many cases. With annotations, the configuration can be done directly in the source code, resulting in less boilerplate code and reducing the overall configuration effort. This promotes a more streamlined and maintainable development process.
3. Compile-Time Safety: Annotations enable compile-time validation of configuration and dependencies. With annotations like @Autowired, Spring can perform type-checking and ensure that the required dependencies are available at compile time. This helps catch errors early in the development cycle and provides increased reliability and stability.
4. Integration with IDEs: Annotations are well-supported by modern Integrated Development Environments (IDEs) like Eclipse, IntelliJ IDEA, and Spring Tool Suite. IDEs provide features like auto-completion, quick navigation, and error checking for annotations, making it easier for developers to work with Spring applications and ensuring consistency in the configuration.
5. Runtime Flexibility: Annotations offer runtime flexibility and adaptability. Since annotations are processed at runtime, it allows for dynamic behavior and runtime introspection. This enables the Spring container to apply the appropriate configurations and behaviors based on the annotated elements, resulting in greater flexibility and customization.
6. Code Organization and Modularization: Annotations help in organizing and categorizing components. Annotations like @Controller, @Service, and @Repository provide semantic information about the role of a component, making it easier to understand the purpose and responsibilities of different classes. This promotes better code organization and modularization, leading to more maintainable and scalable applications.
7. Integration with Other Frameworks: Annotations in Spring seamlessly integrate with other frameworks and libraries. Many third-party libraries and frameworks provide their own annotations that work in conjunction with Spring annotations, enabling developers to leverage a wide range of features and functionalities.

Drawbacks of using Annotations Autowiring in Spring Framework:

1. Configuration Mix-up: As annotations are placed directly in the source code, the configuration information becomes tightly coupled with the application logic. This can lead to a mix of configuration and business logic, making the code harder to understand and maintain, especially when dealing with complex configurations.
2. Limited Flexibility: Annotations are evaluated at runtime, and their behavior cannot be easily changed without modifying the source code. This limits the flexibility to dynamically adjust the configuration or swap implementations based on different environments or runtime conditions.
3. Dependency on Framework: By using annotations, the code becomes tightly coupled with the Spring framework. This can limit the portability of the codebase and make it harder to switch to a different framework in the future, as the code would need to be refactored to remove the Spring-specific annotations.
4. Scattered Configuration: With annotations, the configuration details are spread across various classes and methods. This can make it challenging to get an overview of the application’s configuration as a whole, leading to difficulty in understanding the complete setup and potentially causing configuration-related issues.
5. Testing Complexity: Annotations can make testing more complex, especially when it comes to unit testing. Testing code that heavily relies on annotations may require additional setup or mocking of dependencies, which can increase the complexity and maintenance effort of test code.
6. Potential Performance Impact: Annotations incur a slight runtime performance overhead due to the additional processing required to interpret and handle them. Although the impact is generally minimal, it can become significant in performance-sensitive applications with a large number of annotated components.
7. Learning Curve and Tooling: Working with annotations may require developers to learn and understand specific annotation-driven configurations and their semantics. Additionally, not all IDEs may have comprehensive tooling support for annotations, which can make it more challenging to navigate, refactor, or troubleshoot annotated code.

To mitigate these drawbacks, it’s important to strike a balance between using annotations for configuration and maintaining a clear separation between configuration and application logic. Leveraging other Spring configuration mechanisms like XML or Java-based configuration can help address some of the limitations associated with annotations.

Using Annotations Autowiring in Spring Framework

In this example, we will create an application that uses these annotations. Before starting the project, ensure that the required JAR files are in the project’s “Referenced Libraries” folder.

Step 1: Create a new file called Employee.java in the src/ directory. Add the following code to the file:

public class Employee
{
    private int id;
    private String name, email;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", email=" + email + "]";
    }
}

This class is a simple POJO class that represents an Employee. Note that the setters, getters, and toString can be automatically added using the “Source Action…” option in the right-click menu of VS Code.

Step 2: Create a new file called EmployeeController.java in the src/ directory. Add the following code to the file:

Note that we have only used the @Autowired annotation without the @Qualifier annotation. In this condition, the application will work only if there is one Employee bean. If there are multiple Employee beans, the @Qualifier annotation needs to be used.

Step 3: In the src/ directory, there must be a file called App.java. Typically, this file is created automatically (when the project is created). This file contains the main() function. Modify the file as follows:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        EmployeeController controller = (EmployeeController) context.getBean("controller");
        controller.printStudent();
    }
}

The main() function reads the Beans.xml file and autowires the EmployeeController object. Finally, the object is used to print the Student object.

Step 4: Create a new file called Beans.xml. Add the following code to the file:

Note that there is only one bean of type Employee. If we have multiple beans of type Employee, the @Qualifier annotation needs to be used.

Step 5: Compile and execute the application. Ensure that the output is as follows:

Step 6: Modify Beans.xml to add another bean of type Employee:

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <bean id = "controller" class = "EmployeeController"></bean>

   <bean id = "employee1" class = "Employee">
      <property name = "id" value = "1" />
      <property name = "name" value = "Employee A" />
      <property name = "email" value = "employee.a@company.com"/>
   </bean>

   <bean id = "employee2" class = "Employee">
      <property name = "id" value = "2" />
      <property name = "name" value = "Employee B" />
      <property name = "email" value = "employee.b@company.com"/>
   </bean>
</beans>

Step 7: Compile and execute the application. An error should be seen:

Step 8: Modify the EmployeeController.java file to add the @Qualifier annotation:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class EmployeeController
{
    @Autowired
    @Qualifier("employee1")
    private Employee e;

    public void printStudent()
    {System.out.println(e.toString());}
}

Step 9: Compile and execute the application. Ensure that the output is as follows:

In the next article, I am going to discuss Spring Framework Java-Based Configuration. Here, in this article, I try to explain Spring Framework Annotations Autowiring with Examples. I hope you enjoy this Spring Framework Annotations Autowiring article.