I am going through some blogs on SpringSource and in one of the blogs, author is using @Inject
and I suppose he can also use @Autowired
.
Here is the piece of code:
@Inject private CustomerOrderService customerOrderService;
I am not sure about the difference between @Inject
and @Autowired
and would appreciate it if someone explained their difference and which one to use under what situation?
This question is related to
java
spring
dependency-injection
autowired
inject
@Autowired(required=false) By default the dependency injection for @Autowired must be fulfilled because the value of required attribute is true by default. We can change this behavior by using @Autowired(required=false). In this case if bean is not found for dependency injection, it will not through error.
Please have look at https://www.concretepage.com/spring/spring-autowired-annotation#required-false
But @Inject doesn’t need (required=false) it will not through error if dependency is not found
To handle the situation in which there is no wiring, beans are available with @Autowired
required
attribute set to false
.
But when using @Inject
, the Provider interface works with the bean which means that the bean is not injected directly but with the Provider.
Better use @Inject all the time. Because it is java configuration approach(provided by sun) which makes our application agnostic to the framework. So if you spring also your classes will work.
If you use @Autowired it will works only with spring because @Autowired is spring provided annotation.
The @Inject
annotation is one of the JSR-330 annotations collection. This has Match by Type,Match by Qualifier, Match by Name execution paths.
These execution paths are valid for both setter and field injection.The behavior of @Autowired
annotation is same as the @Inject
annotation. The only difference is the @Autowired
annotation is a part of the Spring framework. @Autowired
annotation also has the above execution paths. So I recommend the @Autowired
for your answer.
@Inject
has no 'required' attribute
@Autowired
annotation is defined in the Spring framework.
@Inject
annotation is a standard annotation, which is defined in the standard "Dependency Injection for Java" (JSR-330). Spring (since the version 3.0) supports the generalized model of dependency injection which is defined in the standard JSR-330. (Google Guice frameworks and Picocontainer framework also support this model).
With @Inject
can be injected the reference to the implementation of the Provider
interface, which allows injecting the deferred references.
Annotations @Inject
and @Autowired
- is almost complete analogies. As well as @Autowired
annotation, @Inject
annotation can be used for automatic binding properties, methods, and constructors.
In contrast to @Autowired
annotation, @Inject
annotation has no required
attribute. Therefore, if the dependencies will not be found - will be thrown an exception.
There are also differences in the clarifications of the binding properties. If there is ambiguity in the choice of components for the injection the @Named
qualifier should be added. In a similar situation for @Autowired
annotation will be added @Qualifier
qualifier (JSR-330 defines it's own @Qualifier
annotation and via this qualifier annotation @Named
is defined).
As of Spring 3.0, Spring offers support for JSR-330 dependency injection annotations (@Inject
, @Named
, @Singleton
).
There is a separate section in the Spring documentation about them, including comparisons to their Spring equivalents.
The key difference(noticed when reading the Spring Docs) between @Autowired
and @Inject
is that, @Autowired
has the 'required' attribute while the @Inject has no 'required' attribute.
In addition to the above:
@Autowired
beans is Singleton whereas using JSR 330 @Inject
annotation it is like Spring's prototype.@Inject
.@Inject
.Here is a blog post that compares @Resource
, @Inject
, and @Autowired
, and appears to do a pretty comprehensive job.
From the link:
With the exception of test 2 & 7 the configuration and outcomes were identical. When I looked under the hood I determined that the ‘@Autowired’ and ‘@Inject’ annotation behave identically. Both of these annotations use the ‘AutowiredAnnotationBeanPostProcessor’ to inject dependencies. ‘@Autowired’ and ‘@Inject’ can be used interchangeable to inject Spring beans. However the ‘@Resource’ annotation uses the ‘CommonAnnotationBeanPostProcessor’ to inject dependencies. Even though they use different post processor classes they all behave nearly identically. Below is a summary of their execution paths.
Tests 2 and 7 that the author references are 'injection by field name' and 'an attempt at resolving a bean using a bad qualifier', respectively.
The Conclusion should give you all the information you need.
Source: Stackoverflow.com