Difference between @AutoWired and @Qualifier in Spring Framework?

Hello guys, if you are preparing for Spring Framework or Spring Boot interviews then you should always prepare comparison questions like what is difference between @Qualifier and @AutoWired annotation in Spring? This kind of questions are good to demonstrate not only your knowledge but also how well you understand them and its also your chance to impress the interviewer. In the past, I have answered @Bean vs @Component and @Controller vs @RestController annotation and in this article, I am going to explain you the difference between @Autowired and @Qualifier in Spring Framework. 
After going through this article, you will not only understand their difference better but also you can use them more effectively.  Spring Framework is a powerful platform for building enterprise level applications. 

One of the key concepts in Spring is Dependency Injection (DI), which allows developers to manage the dependencies between components and promote loose coupling. Two commonly used annotations for DI in Spring are @Autowired and @Qualifier.

In this article, we'll take an in-depth look at these annotations and compare their features and usage to determine which one reigns supreme in the world of Spring Dependency Injection.

 

What is @Autowired Annotation in Spring?

We inject dependencies using @Autowired annotation into our java classes. It is a type-level annotation that can be applied to fields, methods, and constructors of a class. When Spring encounters the @Autowired annotation, it searches for a bean of the same type that can be injected into the component.

For example, suppose we have a UserService class that requires a UserRepository dependency to perform CRUD operations on the database. We can use the @Autowired annotation to inject the UserRepository into the UserService class as follows:

@Service

public class UserService {

 

    @Autowired

    private UserRepository userRepository;

 

    // ...

}

In the above code, the @Autowired annotation is applied to the userRepository field, which indicates that Spring should look for a bean of type UserRepository and inject it into the field.

@Autowired can be achieved using:

• Field Injection

@Service

public class UserService {

 

    @Autowired

    private UserRepository userRepository;

 

    // ...

}

In the above example, the @Autowired annotation is used to inject an instance of UserRepository into the userRepository field of the UserService class. This is a type of field injection, where the dependency is injected directly into the class field.

• Constructor Injection

@Service

public class UserService {

 

    private final UserRepository userRepository;

 

    @Autowired

    public UserService(UserRepository userRepository) {

        this.userRepository = userRepository;

    }

 

    // ...

}

In this example, the @Autowired annotation is used to inject an instance of UserRepository into the constructor of the UserService class. This is a type of constructor injection, where the dependency is injected into the class constructor as a parameter.

• Setter Injection

@Service

public class UserService {

 

    private UserRepository userRepository;

 

    @Autowired

    public void setUserRepository(UserRepository userRepository) {

        this.userRepository = userRepository;

    }

 

    // ...

}

In this example, the @Autowired annotation is used to inject an instance of UserRepository into the setUserRepository() method of the UserService class. This is a type of setter injection, where the dependency is injected into a class method. 

It's worth noting that @Autowired can also be used in conjunction with other annotations, such as @Qualifier, to provide more control over the injection process. For example, if there are multiple implementations of the UserRepository interface, we can use the @Qualifier annotation to specify which implementation we want to inject. Here's an example:

What is @Qualifier annotation in Spring? What does it do?

To distinguish between distinct beans of the same type that are acceptable for injection, use the @Qualifier annotation. It is a method-level annotation that may be used with @Autowired to provide the injection process additional control.

Assume, for instance, that we have two UserRepository implementations: MongoUserRepository and JpaUserRepository. To define the implementation we wish to inject into the UserService class, we may use the @Qualifier annotation as seen below:

@Service

public class UserService {

 

    @Autowired

    @Qualifier("mongoUserRepository")

    private UserRepository userRepository;

 

    // ...

}

In the above code, the @Qualifier("mongoUserRepository") annotation is used to specify that we want to inject the MongoUserRepository bean into the userRepository field. If we didn't use the @Qualifier annotation, Spring wouldn't know which implementation to inject and would throw an exception.

To aid Spring Framework in selecting the appropriate bean for autowiring, use @Qualifier in conjunction with @Autowired. If confusing bean types are discovered, Spring Framework will prompt you to explicitly pick the bean; in this case, you should supply the qualifier.

Note: When launching your application, you will get a NoUniqueBeanDefinitionException if you do not specifically state which bean one you want to inject.

An example of @Autowired vs @Qualifier in Spring

Let's say we have an e-commerce website that sells books, and we want to use Spring to manage our shopping cart functionality. We have two implementations of the CartService interface: InMemoryCartService and DatabaseCartService. We want to use InMemoryCartService for testing purposes and DatabaseCartService for production. To accomplish this, we can use @Qualifier to specify which implementation of CartService should be injected based on the active Spring profile. 

Here's an example:

@Service

@Profile("test")

@Qualifier("inMemoryCartService")

public class InMemoryCartService implements CartService {

 

    // ...

}

@Service

@Profile("!test")

@Qualifier("databaseCartService")

public class DatabaseCartService implements CartService {

 

    // ...

}

In the above example, we use @Profile to specify that InMemoryCartService should only be used when the "test" profile is active, and DatabaseCartService should be used for all other profiles. We also use @Qualifier to specify unique identifiers for each implementation of CartService. 

Now, let's say we have a ShoppingCart class that requires a CartService dependency. We can use @Autowired and @Qualifier to inject the correct implementation of CartService based on the active Spring profile:

@Component

public class ShoppingCart {

 

    @Autowired

    @Qualifier("inMemoryCartService")

    private CartService cartService;

 

    // ...

}

In this example, when the "test" profile is active, an instance of InMemoryCartService will be injected into the cartService field of the ShoppingCart class. When any other profile is active, an instance of DatabaseCartService will be injected. Using @Qualifier in conjunction with Spring profiles allows us to easily switch between different implementations of a dependency based on the environment or context in which our application is running.

Differences between @Autowired and @Qualifier in Spring Framework

Now that you have fair idea of what is @Autowired and @Qualifier annotation and when and how to use them, its time to see the difference between them. I have compared them on key points like functionality, scope and usage, let's see them:

1. Functionality
The @Autowired annotation is used to inject dependencies into a Spring-managed bean, while the @Qualifier annotation is used to differentiate between multiple beans of the same type that are eligible for injection.

2. Scope
The @Autowired annotation is a type-level annotation that can be applied to fields, methods, and constructors, while the @Qualifier annotation is a method-level annotation that can be used in conjunction with @Autowired.

3. Usage
When there is only one bean of a given type, the @Autowired annotation is used; when there are several beans of the same type, the @Qualifier annotation is used.


That's all about the difference between @Autowired and @Qualifier annotation in Spring Framework. In summary, maintaining dependencies in Spring applications requires the use of both the @Autowired and @Qualifier annotations. The @Qualifier annotation is used to distinguish between distinct beans of the same type that are suitable for injection, whereas the @Autowired annotation is used to inject dependencies into a Spring-managed bean. We can effectively separate components and obtain fine-grained control over the injection process by combining these annotations.