Spring’s @Resource Annotation

By Atul Rai | Last Updated: October 7, 2023 Previous       Next

In the world of Java development, the Spring Framework has established itself as a powerful and versatile framework for building enterprise applications. One of the essential features of Spring is its support for Dependency Injection, which allows developers to manage and wire up components effortlessly. In this blog, we will delve into one of the commonly used annotations in Spring, the @Resource annotation, and understand its purpose, usage, and benefits with practical examples.

1. What is the @Resource Annotation?

The @Resource annotation is a part of the Java EE (Enterprise Edition) specification and is supported by the Spring Framework. It is used to declare a dependency on a resource, typically a bean or other managed component. The primary purpose of this annotation is to inject resources into your Spring beans, enabling them to access those resources seamlessly.

2. Usage of @Resource Annotation

The @Resource annotation can be used in various scenarios, such as injecting dependencies, specifying the name of the resource to be injected, and dealing with ambiguous dependencies. Here’s how you can use it:

2.1 Basic Usage

In its simplest form, you can use the @Resource annotation to inject a Spring bean into another bean. For example:

@Service
public class OrderService {
    @Resource
    private ProductRepository productRepository;
    
    // ...
}

In this example, the OrderService bean injects the ProductRepository bean using the @Resource annotation.

2.2 Specifying Resource Name

You can specify the name of the resource to be injected by providing the name attribute in the @Resource annotation. This is particularly useful when you have multiple beans of the same type, and you want to disambiguate them. For instance:

@Service
public class OrderService {
    @Resource(name = "productRepository")
    private ProductRepository productRepo;
    
    // ...
}

Here, we’ve explicitly mentioned that the productRepo bean should be injected with the bean named “productRepository”.

Similar Post: Spring autowiring using @Resource and @Inject annotation example

2.3 Dealing with Ambiguity

If multiple beans of the same type exist and you want to disambiguate them based on their qualifiers, you can use the @Qualifier annotation in conjunction with @Resource. For example:

@Service
public class OrderService {
    @Resource
    @Qualifier("mysqlProductRepository")
    private ProductRepository productRepo;
    
    // ...
}

In this case, we’ve combined @Resource with @Qualifier to specify that the productRepo bean should be injected with the bean named “mysqlProductRepository.”

3. Using @Resource with Spring

Let’s explore a complete example to illustrate how the @Resource annotation works in a Spring application. Suppose we have a simple e-commerce application with a ProductRepository and an OrderService:

public interface ProductRepository {
    List<Product> findAll();
}

@Repository("mysqlProductRepository")
public class MySqlProductRepository implements ProductRepository {
    // Implementation for MySQL database
}

@Repository("h2ProductRepository")
public class H2ProductRepository implements ProductRepository {
    // Implementation for H2 in-memory database
}

@Service
public class OrderService {
    @Resource
    @Qualifier("mysqlProductRepository")
    private ProductRepository productRepo;

    public List<Product> getAllProducts() {
        return productRepo.findAll();
    }
}

In this example, we have two implementations of ProductRepository for different database systems. The OrderService uses the @Resource annotation with a @Qualifier to inject the mysqlProductRepository.

4. Benefits of Using @Resource

The @Resource annotation offers several benefits in a Spring application:

1. Simplicity: It simplifies the process of injecting resources into beans, reducing the need for complex configuration.
2. Type Safety: It ensures type safety by injecting resources by their types, making it harder to inject the wrong resource.
3. Resource Naming: You can specify the name of the resource explicitly, helping to disambiguate resources when multiple beans of the same type exist.
4. Integration with Java EE: The @Resource annotation aligns with Java EE standards, making it suitable for Java EE environments.

Summary

The @Resource annotation is a valuable tool in the Spring framework, enabling easy resource injection and management. It simplifies dependency injection, improves code readability, and provides a way to handle resource ambiguity in a Spring application.

References

1. Injection with @Resource – SpringDoc
2. Annotation Type Resource – JavaDoc
3. Spring autowiring using @Resource and @Inject annotation example
4. Spring @Autowired Annotation Example