Difference between @Autowired and @Qualifier Annotation in Spring Framework? Example Tutorial

Hello Java programmers, the difference between @Autowired and @Qualifier annotations in Spring is a common question frequently asked in Spring on Java interviews, and if you are looking for an answer then you have come to the right place. Earlier, I have shared the best Spring courses and books, and in this article, Since most Java developers are familiar with annotations in Spring, they need to understand the difference between them and where to use them. Autowiring is a Spring Framework feature that enables you to inject the object dependency implicitly. This was added to Spring 2.5 to make an annotations-driven dependency injection that helps to "injects" objects into other objects or "dependencies." 

Both @Autowired and @Qualifier are two different methods of autowire annotations that are used to achieve dependency injection in Spring.

You can use @Qualifier along with @Autowired to help Spring Framework find the right bean to autowire. Spring Framework will ask you explicitly select the bean if ambiguous bean types are found, in which case you should provide the qualifier. 

The @Qualifier annotation can be used on any class annotated with @Component or on any methods annotated with @Bean annotations. It can also be applied to constructor arguments and method parameters.

@Autowired and @Qualifier Annotation Example in Spring Framework

Now, let's see an example of how to use @Autowired and @Qualifier annotation in Spring Framework. Assuming, there Employee interface has two methods with calculateSalary() and calculateDeductions(). 

public interface Employee {
    public void calculateSalary();
    public void calculateDeductions();
}

There are two beans, Software Engineer and Quality Assurance Engineer, implement the Employee interface. 

@Component(value = "softwareengineer")
public class SoftwareEngineer implements Employee {

    @Override
    public void calculateSalary() {
        System.out.println("Calculate Software Engineer Salary");
    }

    @Override
    public void calculateDeductions() {
        System.out.println("Calculate total salary
            deduction of software Engineer");
    }
}

@Component(value = " qaengineer ")
public class QAEngineer implements Employee {

    @Override
    public void calculateSalary() {
        System.out.println("Calculate Quality Assurance Engineer Salary");
    }

    @Override
    public void calculateDeductions() {
        System.out.println("Calculate total salary deduction of 
             Quality Assurance Engineer");
    }
}

So as from the injecting bean in EmployeeService using @Autowired with @Qualifier annotation.  If you don't use @Qualifier annotations then it will throw the      NoUniqueBeanDefinitionException because Spring doesn't know which bean should autowire. 

To avoid this confusion or exception, we should use @Qualifier annotation.

 

To uniquely identify the different beans, we should use the @Qualifier annotation along with @Autowired.

@Component
public class EmployeeService {

    @Autowired
    @Qualifier("softwareengineer")
    private Employee employee;

    public void service() {
        employee.calculateSalary();
        employee.calculateDeductions();
    }
}

@Autowired vs @Qualifier Annotation in SpringFramework

Now, let's compare different features of @Autowired and @Qualifier in Spring Framework. The @Autowired annotation can be used alone. If it is used alone, it will be wired by type. So problems arise if more than one bean of the same type is declared in the container as @Autowired does not know which beans to use to inject.

As a result, use @Qualifier together with @Autowired to clarify which beans to be wired by specifying the bean name

Java developers can use qualifiers to provide various implementations of a particular bean type. A qualifier is an annotation that you apply to a bean. A qualifier type is a Java annotation defined as @Target({METHOD, FIELD, PARAMETER, TYPE}) and @Retention(RUNTIME).

On the other hand, @Autowired annotation supports fields, setter, constructors, and multi-argument methods injection.

Summary

Here is an excellent summary of Spring annotations and their use cases. This is useful to find equivalent standard annotations for a spring-specific annotation.

Spring purposefully added the @Qualifier to remove the confusion by specifying which exact bean will be wired. Following is an example of a show of @Qualifier annotation.

Think about a Student class that has a bean which is called student1. Then should have to connect with the specific bean to identify each uniquely. Here is an example of using @Qualifier annotation along with @Autowired annotation.

That's all about the difference between @Autowired and @Qualifier annotation in Spring MVC and REST. @Qualifier is nothing but used to identify the beans which are operating uniquely. In order to make the simple use of beans, this was added to Spring 4 onwards.

If you are creating RESTful web services, it's better to use both annotations, which gives you a clear picture of what beans you are using for various purposes. 

Other Java and Spring Tutorial you may like

• How to use @Bean in Spring framework (Example)
• How Spring MVC works internally? (answer)
• Spring Data JPA @Query Example (query example)
• Spring Data JPA Repository (JpaReposistory example)
• 20+ Spring MVC Interview Questions for Programmers (answer)
• 13 Spring Boot Actuator Interview questions (boot questions)
• Difference between @Autowired and @Inject in Spring? (answer)
• What is @Conditional annotation in Spring? (conditional example)
• Top 5 Frameworks Java Developer Should Know (frameworks)
• 10 Advanced Spring Boot Courses for Java developers (courses)
• Difference between @RequestParam and @PathVariable in Spring (answer)
• Top 7  Courses to learn Microservices in Java (courses)
• Top 5 Courses to Learn and Master Spring Cloud (courses)
• 5 Courses to Learn Spring Security for Java programmers (courses)
• Top 5 Spring Boot Annotations Java Developers should know (read)
• Top 5 Spring Cloud annotations Java programmer should learn (cloud)
• 5 Courses to learn Spring Cloud for Microservices (courses)
• 10 Spring MVC annotations Java developer should learn (annotations)
• @SpringBootApplication vs @EnableAutoConfiguration? (answer)
• 15 Spring Boot Interview Questions for Java Developers (questions)
• Difference between @Component, @Service, and @Controller in Spring (answer)

Thanks for reading this article so far. If you find this Spring @Bean Tutorial and Example then please share it with your friends and colleagues. If you have any questions or feedback then please drop a note.

P. S. - If you are a beginner and want to learn the Spring MVC from scratch, and looking for some best online resources then you can also check out these the best Spring MVC courses for beginners. This list contains free Udemy and Pluralsight courses to learn Spring MVC from scratch.