10 Autowired Interview Questions and Answers

Autowired is a powerful feature in the Spring Framework that simplifies dependency injection, making it easier to manage and configure beans in a Spring application. By automatically resolving and injecting the required dependencies, Autowired reduces boilerplate code and enhances the modularity and testability of your application. This feature is particularly useful in large-scale applications where manual dependency management can become cumbersome and error-prone.

This article provides a curated selection of interview questions focused on Autowired, designed to help you understand its nuances and applications. By familiarizing yourself with these questions and their answers, you will be better prepared to demonstrate your expertise in Spring Framework’s dependency injection mechanisms during your technical interviews.

Autowired Interview Questions and Answers

1. Explain what @Autowired is and its primary purpose in Spring.

@Autowired is an annotation in the Spring framework used for automatic dependency injection. Its main purpose is to eliminate the need for explicit wiring in configuration files by allowing Spring to automatically resolve and inject required dependencies, making the code cleaner and easier to manage.

When you use @Autowired, Spring’s dependency injection mechanism automatically finds the appropriate bean from the application context and injects it into the annotated field, constructor, or method. This is useful for managing dependencies in large applications where manual wiring can become cumbersome.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    private Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    // other methods
}

@Component
public class Engine {
    // Engine properties and methods
}

In this example, the Car class depends on the Engine class. By using @Autowired on the constructor, Spring automatically injects an instance of Engine when creating an instance of Car.

2. Write a simple example of using @Autowired to inject a service into a controller.

In Spring, @Autowired is used for automatic dependency injection, particularly useful in a layered architecture for injecting a service into a controller.

Here is a simple example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    public String serve() {
        return "Service is working";
    }
}

@Controller
public class MyController {

    private final MyService myService;

    @Autowired
    public MyController(MyService myService) {
        this.myService = myService;
    }

    public void doSomething() {
        System.out.println(myService.serve());
    }
}

In this example, MyService is a service class annotated with @Service. The MyController class, annotated with @Controller, depends on MyService. The @Autowired annotation in the constructor of MyController injects an instance of MyService.

3. Demonstrate how to use @Autowired for constructor-based dependency injection.

@Autowired is used to automatically inject dependencies into a class. Constructor-based dependency injection provides dependencies through the class constructor, preferred for mandatory dependencies.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ServiceA {
    private final ServiceB serviceB;

    @Autowired
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    public void performAction() {
        serviceB.execute();
    }
}

@Component
public class ServiceB {
    public void execute() {
        System.out.println("ServiceB is executing...");
    }
}

In this example, ServiceA depends on ServiceB. The @Autowired annotation on the constructor of ServiceA tells Spring to inject an instance of ServiceB when creating ServiceA.

4. Show how to use @Autowired for field-based dependency injection.

@Autowired allows Spring to resolve and inject collaborating beans into your bean. Field-based dependency injection directly injects the dependency into the field of a class.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Autowired
    private MyRepository myRepository;

    public void performService() {
        myRepository.doSomething();
    }
}

In this example, MyRepository is automatically injected into the myRepository field of MyService by Spring. The @Component annotation indicates that MyService is a Spring-managed bean.

5. Provide an example of setter-based dependency injection using @Autowired.

Setter-based dependency injection involves Spring injecting dependencies into a bean via setter methods. The @Autowired annotation marks the setter method for dependency injection.

Example:

public class MyService {
    private MyRepository myRepository;

    @Autowired
    public void setMyRepository(MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    public void performService() {
        myRepository.doSomething();
    }
}

In this example, the MyService class depends on MyRepository. The @Autowired annotation on the setMyRepository method tells Spring to inject an instance of MyRepository when it creates an instance of MyService.

6. How would you handle an optional dependency using @Autowired?

To handle an optional dependency using @Autowired, you can set the required attribute to false. This tells Spring that the dependency is not mandatory, and if it is not found, the field will be left as null.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Autowired(required = false)
    private OptionalDependency optionalDependency;

    public void performService() {
        if (optionalDependency != null) {
            optionalDependency.execute();
        } else {
            System.out.println("Optional dependency is not available.");
        }
    }
}

In this example, the optionalDependency is injected only if it is available in the Spring context. If it is not available, the field remains null, and the application can handle this scenario gracefully.

7. Write a code snippet showing how to use @Qualifier with @Autowired to inject a specific bean.

@Autowired is used for automatic dependency injection, and @Qualifier specifies which bean to inject when there are multiple beans of the same type.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    private final MyRepository myRepository;

    @Autowired
    public MyService(@Qualifier("specificRepository") MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    // other methods
}

8. Explain how to use @Primary with @Autowired and provide a code example.

@Autowired automatically injects dependencies into a class. When multiple beans of the same type are available, @Primary indicates which bean should be preferred.

Example:

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
public class FooService implements Service {
    // Implementation details
}

@Component
@Primary
public class BarService implements Service {
    // Implementation details
}

@Component
public class MyComponent {
    private final Service service;

    @Autowired
    public MyComponent(Service service) {
        this.service = service;
    }

    // Other methods
}

In this example, both FooService and BarService implement the Service interface. By marking BarService with @Primary, Spring will inject an instance of BarService into MyComponent.

9. What are circular dependencies, and how can they be resolved in Spring?

Circular dependencies in Spring occur when two or more beans depend on each other, creating a cycle that can cause issues during bean initialization. For example, if Bean A depends on Bean B and Bean B depends on Bean A, Spring may not resolve these dependencies correctly, leading to a BeanCurrentlyInCreationException.

There are several ways to resolve circular dependencies in Spring:

• Setter Injection: Instead of using constructor injection, use setter injection to break the circular dependency. This allows Spring to create the beans first and then set the dependencies.
• @Lazy Annotation: Use the @Lazy annotation to delay the initialization of one of the beans until it is needed. This can help break the cycle by ensuring that one of the beans is not created immediately.

Example:

@Component
public class BeanA {
    private BeanB beanB;

    @Autowired
    public void setBeanB(@Lazy BeanB beanB) {
        this.beanB = beanB;
    }
}

@Component
public class BeanB {
    private BeanA beanA;

    @Autowired
    public void setBeanA(BeanA beanA) {
        this.beanA = beanA;
    }
}

In this example, BeanA and BeanB depend on each other. By using setter injection and the @Lazy annotation, we can break the circular dependency and allow Spring to initialize the beans correctly.

10. Explain the role of @Autowired(required = false) and provide an example.

@Autowired(required = false) allows for optional dependency injection. By default, @Autowired is required, meaning Spring will throw an exception if the dependency is not found. However, setting required = false makes the dependency optional, allowing the application to continue running even if the bean is not present.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Autowired(required = false)
    private OptionalDependency optionalDependency;

    public void performService() {
        if (optionalDependency != null) {
            optionalDependency.execute();
        } else {
            System.out.println("Optional dependency is not available.");
        }
    }
}

@Component
public class OptionalDependency {
    public void execute() {
        System.out.println("Executing optional dependency.");
    }
}

In this example, MyService has an optional dependency on OptionalDependency. If OptionalDependency is not available in the Spring context, the application will still run without throwing an exception.