Spring : Difference between @Autowired, @Inject and @Resource

Points To Remember

• @Inject is not a spring feature you need to include javax inject dependency in order to use @Inject.
• @Autowired is Spring annotation used to inject dependency just like @Inject. It use @Qualifier annotation to differentiate between the beans.
• @Resource is also Spring annotation, but it uses bean name to inject dependencies and differentiate between beans.

Problem Statement :: Structure

In order to show how @Autowired @Inject and @Resource annotations work  we will create 3 services

• Interface PersonService, this is the interface for all person related operations.
• Class EngineerService, this is the service that will do operations for engineer.
• Class ManagerService, this is the service that will do operations for manager.

Here, both EngineerService and ManagerService implements PersonService. Now we will try to add the services to a controller by different  ways to test how @Autowire, @Inject and @Resource will work.

So the above structure looks like as shown in the code below.

view plaincopy to clipboardprint?

1. public interface PersonService {  
2.   
3.     public String getName();  
4. }  
5.   
6.   
7. @Service  
8. public class EngineerService implements PersonService {  
9.   
10.     @Override  
11.     public String getName() {  
12.         return "EngineerService";  
13.     }  
14.   
15. }  
16.   
17. @Service  
18. public class ManagerService implements PersonService {  
19.   
20.     @Override  
21.     public String getName() {  
22.         return "ManagerService";  
23.     }  
24. }  

public interface PersonService { public String getName(); } @Service public class EngineerService implements PersonService { @Override public String getName() { return "EngineerService"; } } @Service public class ManagerService implements PersonService { @Override public String getName() { return "ManagerService"; } }

Test with @Autowired annotations

1. Parent Reference Type and name

   view plaincopy to clipboardprint?

   1. @RestController  
   2. public class PersonController {  
   3.   
   4.     @Autowired  
   5.     private PersonService personService;  
   6.   
   7.     @Resource  
   8.     private PersonService personService;  
   9.   
   10.     @Inject  
   11.     private PersonService personService;  
   12. }  

   @RestController public class PersonController { @Autowired private PersonService personService; @Resource private PersonService personService; @Inject private PersonService personService; }
   In this case @Autowired @Inject and @Resource all will throw the following exception.
   
   Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException
   
   

2. Parent Reference Type and Child Reference Name

   view plaincopy to clipboardprint?

   1. @RestController  
   2. public class PersonController {  
   3.   
   4.     @Autowired  
   5.     private PersonService engineerService;  
   6.   
   7.     @Resource  
   8.     private PersonService engineerService;  
   9.   
   10.     @Inject  
   11.     private PersonService engineerService;  
   12.   
   13. }  

   @RestController public class PersonController { @Autowired private PersonService engineerService; @Resource private PersonService engineerService; @Inject private PersonService engineerService; }
   In this case, all @Autowired, @Inject and @Resource annotations will inject EngineerService, and getName() will return "EngineerService".
   Note :: When beans are created, they are created by name of the class, EngineerService will resolve to engineerService and its bean will be resolved by name engineerService. Hence when we try to use it with PersonService engineerService , this will inject engineerService bean.
3. view plaincopy to clipboardprint?

   1. public interface PersonService {  
   2.   
   3.     public String getName();  
   4. }  
   5.   
   6. @Service  
   7. @Qualifier(value = "engineer")  
   8. public class EngineerService implements PersonService {  
   9.   
   10.     @Override  
   11.     public String getName() {  
   12.         return "EngineerService";  
   13.     }  
   14.   
   15. }  
   16.   
   17. @Service  
   18. @Qualifier(value = "manager")  
   19. public class ManagerService implements PersonService {  
   20.   
   21.     @Override  
   22.     public String getName() {  
   23.         return "ManagerService";  
   24.     }  
   25. }  
   26.   
   27. @RestController  
   28. public class PersonController {  
   29.   
   30.     @Autowired  
   31.     @Qualifier(value = "engineer")  
   32.     private PersonService personService;  
   33.   
   34.     @Resource  
   35.     @Qualifier(value = "engineer")  
   36.     private PersonService personService;  
   37.   
   38.     @Inject  
   39.     @Qualifier(value = "engineer")  
   40.     private PersonService personService;  
   41.   
   42. }  

   public interface PersonService { public String getName(); } @Service @Qualifier(value = "engineer") public class EngineerService implements PersonService { @Override public String getName() { return "EngineerService"; } } @Service @Qualifier(value = "manager") public class ManagerService implements PersonService { @Override public String getName() { return "ManagerService"; } } @RestController public class PersonController { @Autowired @Qualifier(value = "engineer") private PersonService personService; @Resource @Qualifier(value = "engineer") private PersonService personService; @Inject @Qualifier(value = "engineer") private PersonService personService; }
   In this case, all will inject the EngineerService bean to the PersonCOntroller. This is because we have given names to beans using @Qualifier annotation and then used them with the same name.

4. Ambiguous Qualifiers with Parent Reference Type and name

   view plaincopy to clipboardprint?

   1. public interface PersonService {  
   2.   
   3.     public String getName();  
   4. }  
   5.   
   6. @Service  
   7. @Qualifier(value = "person")  
   8. public class EngineerService implements PersonService {  
   9.   
   10.     @Override  
   11.     public String getName() {  
   12.         return "EngineerService";  
   13.     }  
   14.   
   15. }  
   16.   
   17. @Service  
   18. @Qualifier(value = "person")  
   19. public class ManagerService implements PersonService {  
   20.   
   21.     @Override  
   22.     public String getName() {  
   23.         return "ManagerService";  
   24.     }  
   25. }  
   26.   
   27. @RestController  
   28. public class PersonController {  
   29.   
   30.     @Autowired  
   31.     @Qualifier(value = "person")  
   32.     private PersonService personService;  
   33.   
   34.     @Resource  
   35.     @Qualifier(value = "person")  
   36.     private PersonService personService;  
   37.   
   38.     @Inject  
   39.     @Qualifier(value = "person")  
   40.     private PersonService personService;  
   41.   
   42. }  

   public interface PersonService { public String getName(); } @Service @Qualifier(value = "person") public class EngineerService implements PersonService { @Override public String getName() { return "EngineerService"; } } @Service @Qualifier(value = "person") public class ManagerService implements PersonService { @Override public String getName() { return "ManagerService"; } } @RestController public class PersonController { @Autowired @Qualifier(value = "person") private PersonService personService; @Resource @Qualifier(value = "person") private PersonService personService; @Inject @Qualifier(value = "person") private PersonService personService; }
   In this case, since the qualifiers are ambiguous, all the three will result in the exception.
   
   Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException
   
   This is because spring will not be able to find a unique bean with the qualifier "person".

5. Ambiguous Qualifiers with Parent Reference type and Child Reference name

   view plaincopy to clipboardprint?

   1. public interface PersonService {  
   2.   
   3.     public String getName();  
   4. }  
   5.   
   6. @Service  
   7. @Qualifier(value = "engineer")  
   8. public class EngineerService implements PersonService {  
   9.   
   10.     @Override  
   11.     public String getName() {  
   12.         return "EngineerService";  
   13.     }  
   14.   
   15. }  
   16.   
   17. @Service  
   18. @Qualifier(value = "manager")  
   19. public class ManagerService implements PersonService {  
   20.   
   21.     @Override  
   22.     public String getName() {  
   23.         return "ManagerService";  
   24.     }  
   25. }  
   26.   
   27. @RestController  
   28. public class PersonController {  
   29.   
   30.     @Autowired  
   31.     @Qualifier(value = "engineer")  
   32.     private PersonService engineerService;  
   33.   
   34.     @Resource  
   35.     @Qualifier(value = "engineer")  
   36.     private PersonService engineerService;  
   37.   
   38.     @Inject  
   39.     @Qualifier(value = "engineer")  
   40.     private PersonService engineerService;  
   41.   
   42. }  

   public interface PersonService { public String getName(); } @Service @Qualifier(value = "engineer") public class EngineerService implements PersonService { @Override public String getName() { return "EngineerService"; } } @Service @Qualifier(value = "manager") public class ManagerService implements PersonService { @Override public String getName() { return "ManagerService"; } } @RestController public class PersonController { @Autowired @Qualifier(value = "engineer") private PersonService engineerService; @Resource @Qualifier(value = "engineer") private PersonService engineerService; @Inject @Qualifier(value = "engineer") private PersonService engineerService; }
   In this case, @Autowired and @Inject will throw the following exception
   
   Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException
   But, @Resouce will still inject the EngineerService bean.

Hence following conclusion can be made on the basis of the above test scenario's

• All, @Autowired, @Inject and @Resource throws exception with Ambiguous Bean names.
• If Unique Qualifiers are used, all will inject the specified beans.
• If Ambiguous beans are there only @Resouce can inject beans based on names of Bean name.