When to Use @Autowired vs @Resource in Spring: Best Practices and Pitfalls

Overview of @Autowired and @Resource

@Autowired is a Spring‑specific annotation for dependency injection, while @Resource comes from the JSR‑250 (Java EE) standard and is container‑agnostic. Alibaba’s Java development guidelines prefer @Resource, but many developers are unaware of the technical reasons.

IDE Warning for Field Injection

When @Autowired is placed on a field, IntelliJ (and other IDEs) show the warning:

@RestController
public class InjectController {
    @Autowired
    private ConnectService connectService;
}

"Field injection is not recommended. Spring Team recommends: \"Always use constructor‑based dependency injection in your beans. Always use assertions for mandatory dependencies\"."

Moving @Autowired to a setter or constructor removes the warning:

@RestController
public class InjectController {
    private ConnectService connectService;

    @Autowired
    public void setConnectService(ConnectService connectService) {
        this.connectService = connectService;
    }
}

@RestController
public class InjectController {
    private final ConnectService connectService;

    @Autowired
    public InjectController(ConnectService connectService) {
        this.connectService = connectService;
    }
}

The warning targets field injection, not the @Autowired annotation itself.

Spring Dependency‑Injection Styles and Recommended Scenarios

Constructor injection – best for mandatory, immutable dependencies.

Setter injection – suitable for optional or mutable dependencies.

Field injection – should be avoided; if used, prefer @Resource to reduce coupling to Spring.

Drawbacks of Field Injection

Field injection hides dependencies, prevents injection of immutable objects, tightly couples the class to the IoC container, and makes unit testing harder because the container must be involved. It also obscures the number of dependencies, violating the single‑responsibility principle.

Why Only @Autowired Triggers the IDE Warning

@Autowired is Spring‑specific, creating a strong binding to the framework; replacing the container would break such injections. @Resource is defined by JSR‑250, so any compliant IoC container can process it.

By default, @Autowired resolves beans by type (byType). @Resource resolves by name (byName) first, then falls back to type. When multiple beans of the same type exist, @Autowired can cause ambiguity, whereas @Resource can be more precise. @Autowired can also be qualified with @Qualifier to specify a bean name.

Functionality of @Autowired and @Resource

Spring supports JSR‑250 annotations such as @Resource, @PostConstruct, and @PreDestroy. Functionally, @Resource behaves like @Autowired but defaults to byName injection.

@Resource defines two attributes: name – the bean name to inject. type – the bean class to inject.

@Resource Injection Scenarios

If both name and type are specified, Spring looks for a unique bean matching both; otherwise an exception is thrown.

If only name is specified, injection is performed by name; missing beans cause an exception.

If only type is specified, injection is by type; absence or multiple matches cause an exception.

If neither attribute is set (default), Spring first attempts by name, then falls back to by type.

Conclusion

Understanding the IDE warning and the differences between @Autowired and @Resource helps developers choose the most appropriate injection style, balancing code clarity, testability, and framework portability.