Overview

The @Autowired annotation in Spring is a pivotal component of the Spring Framework, used for dependency injection. It allows Spring to resolve and inject collaborating beans into your bean. Understanding @Autowired is crucial for developing loosely coupled applications with Spring, enhancing modularity, testability, and maintainability of the code.

Key Concepts

• Dependency Injection (DI): The core concept behind @Autowired, enabling objects to be provided with their dependencies without creating them directly.
• Automatic Wiring: Spring’s capability to automatically detect and inject the required beans using @Autowired.
• Customization and Flexibility: Advanced configurations that can be applied with @Autowired for specific needs, like required vs. optional dependencies.

Common Interview Questions

Basic Level

1. What is the purpose of the @Autowired annotation in Spring?
2. How does Spring resolve a bean when multiple implementations are available for an @Autowired dependency?

Intermediate Level

3. How can you use @Autowired with collections (List/Set/Map)?

Advanced Level

4. How does Spring handle @Autowired dependencies in terms of bean life cycle, and what are the implications for bean creation order?

Detailed Answers

1. What is the purpose of the @Autowired annotation in Spring?

Answer: The @Autowired annotation in Spring is used for automatic dependency injection. It allows Spring to resolve and inject the necessary beans into other beans without manual bean wiring in the configuration file. This simplifies the development of large Spring applications by promoting loose coupling and making code easier to maintain and test.

Key Points:
- Reduces boilerplate code required for manual wiring.
- Enhances code readability and maintainability.
- Supports constructor, setter, and field injection.

Example:

// Unfortunately, the request was to provide examples in C#, which isn't directly applicable to Spring (a Java framework). 
// Below is a conceptual explanation that would normally be in Java for Spring context.

// A simple Spring service interface
public interface GreetingService {
    String sayGreeting();
}

// Implementation of the GreetingService
@Service
public class SimpleGreetingService implements GreetingService {
    @Override
    public String sayGreeting() {
        return "Hello, World!";
    }
}

// A consumer of the GreetingService using @Autowired for DI
@Component
public class GreetingClient {
    private final GreetingService greetingService;

    @Autowired
    public GreetingClient(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void execute() {
        System.out.println(greetingService.sayGreeting());
    }
}

2. How does Spring resolve a bean when multiple implementations are available for an @Autowired dependency?

Answer: When multiple bean candidates qualify for an @Autowired dependency, Spring resolves the bean to inject by applying certain disambiguation techniques. The primary mechanisms include using the @Primary annotation, @Qualifier annotation, and defining bean names.

Key Points:
- @Primary can be used on one of the candidate beans to give it higher priority.
- @Qualifier specifies which bean to inject by name.
- Bean naming conventions can also influence the resolution process.

Example:

// Example showing @Primary and @Qualifier usage:

// Two implementations of a service interface
@Service
@Primary
public class PrimaryService implements MyService {
    // Implementation details
}

@Service
public class SecondaryService implements MyService {
    // Implementation details
}

// Consumer specifying which bean to use with @Qualifier
@Component
public class ServiceConsumer {
    private final MyService myService;

    @Autowired
    public ServiceConsumer(@Qualifier("secondaryService") MyService myService) {
        this.myService = myService;
    }
}

3. How can you use @Autowired with collections (List/Set/Map)?

Answer: Spring allows injecting collections of beans using @Autowired. This is useful when you have multiple beans of the same type and you want Spring to provide all available beans as a collection. Spring automatically detects and injects all beans matching the collection type.

Key Points:
- Injects all qualifying beans into a List, Set, or Map.
- The Map’s keys are bean names, and values are the corresponding bean instances.
- Useful for strategy pattern implementations or when needing to operate on all beans of a certain type.

Example:

@Component
public class StrategyUser {
    private final Map<String, Strategy> strategies;

    @Autowired
    public StrategyUser(Map<String, Strategy> strategies) {
        this.strategies = strategies;
    }

    public void executeStrategy(String name) {
        strategies.get(name).performTask();
    }
}

4. How does Spring handle @Autowired dependencies in terms of bean life cycle, and what are the implications for bean creation order?

Answer: During the bean life cycle, Spring resolves @Autowired dependencies post-instantiation but before initialization (e.g., before calling any @PostConstruct methods). This means dependencies must be resolvable and available at the time the bean is wired, influencing the creation order of beans in the application context.

Key Points:
- Spring sorts beans considering dependencies to ensure all required beans are created before being injected.
- Circular dependencies require careful management, typically resolved through setter or field injection rather than constructor injection.
- Understanding the bean life cycle is crucial for designing complex applications with interdependent components.

Example:

// Conceptual explanation; specific code example would be less illustrative for this abstract concept.
// Spring takes care of the order of bean creation and initialization to ensure all dependencies are properly resolved when using @Autowired.

Note: The examples provided are in Java, as Spring Framework is primarily used with Java.