Inject and Resource and Autowired annotations

What's the difference between @Inject and @Resource and @Autowired annotations?

When should we use each of them?

The difference between @Inject vs. @Autowire vs. @Resource?

@Autowired: spring propriety annotation (as opposed to @Inject and @Resource) that inject a resource by-type, i.e. by the class of by the interface of the annotated field or contractor. In case we have few implementation of an interface or a subclass we can narrow down the selection using the @Qualifier annotation to avoid ambiguity. For a fallback match, the bean name is considered a default qualifier value. Although you can use this convention to refer to specific beans by name, @Autowired is fundamentally about type-driven injection with optional semantic qualifiers.

@Inject: Annotation based on JSR-330 (Dependency Injection for Java) identifies injectable constructors, methods, and fields. This annotation is an almost complete drop-in replacement for Spring’s @Autowired annotation. So, instead of using the Spring-specific @Autowired annotation, you might choose to use @Inject. One of the differences between @Autowired and @Inject is that @Inject does not have the required field so in case we fail to find a suitable object to inject it will fail while @Autowired can used required=false and allow null able field (only if required!). Advantage of @Inject annotation is that rather than inject a reference directly, you could ask @Inject to inject a Provider. The Provider interface enables, among other things, lazy injection of bean references and injection of multiple instances of a bean. In case we have few implementation of an interface or a subclass we can narrow down the selection using the @Named annotation to avoid ambiguity. @Named annotation works much like Spring’s @Qualifier

@Resource: annotation based on JSR-250. @Resource is quite similar to @Autowired and @Inject, but the main difference is the execution paths taken to find out the required bean to inject. @Resource will narrow down the search first by name then by type and finally by Qualifiers (ignored if match is found by name). @Autowired and @Inject will narrow down the search first by type then by qualifier and finally by the name.

|------------|---------------|---------------|---------------|-----------------------|
|            | Setter/Field  | Constructor   | Applicable to | Matching order        |
|            | injection     | injection     | type          |                       |
|------------|---------------|---------------|---------------|-----------------------|
| @Autowired |       X       |       X       |               | Type, Qualifier, Name |
|------------|---------------|---------------|---------------|-----------------------|
| @Inject    |       X       |       X       |               | Type, Qualifier, Name |
|------------|---------------|---------------|---------------|-----------------------|
| @Resource  |       X       |               |       X       | Name, Type, Qualifier |
|------------|---------------|---------------|---------------|-----------------------|

So in Spring dependency injection @Inject and @Autowired have exactly the same behaviour.

In addition to @Haim answer there is good description of the difference between Spring and JSR-330 (Dependency Injection for Java) annotations and how to use the last with Spring.