@Qualifier for ambiguous beans in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when two beans of the same type exist without @Qualifier?

Consider a Spring Boot application with two beans of the same type but no @Qualifier annotation. What will happen when Spring tries to inject this type?

Spring Boot

public interface Service { void execute(); }

@Service
public class ServiceA implements Service { public void execute() { System.out.println("ServiceA"); } }

@Service
public class ServiceB implements Service { public void execute() { System.out.println("ServiceB"); } }

@Component
public class Client {
    private final Service service;
    public Client(Service service) { this.service = service; }
}

A Spring will throw a NoUniqueBeanDefinitionException due to ambiguity.

B Spring will inject ServiceA by default without error.

C Spring will inject both beans as a list automatically.

D Spring will inject ServiceB by default without error.

💡 Hint

Think about what happens when Spring finds multiple beans of the same type but no qualifier to distinguish them.

When multiple beans of the same type exist and no @Qualifier is used, Spring cannot decide which one to inject and throws a NoUniqueBeanDefinitionException.

📝 Syntax

intermediate

Which @Qualifier usage correctly injects the 'serviceB' bean?

Given two beans named 'serviceA' and 'serviceB', which constructor injection correctly uses @Qualifier to inject 'serviceB'?

Spring Boot

@Service("serviceA")
public class ServiceA implements Service {}

@Service("serviceB")
public class ServiceB implements Service {}

@Component
public class Client {
    private final Service service;
    public Client(@Qualifier("serviceB") Service service) {
        this.service = service;
    }
}

A public Client(@Qualifier(serviceB) Service service) { this.service = service; }

B public Client(@Qualifier("serviceB") Service service) { this.service = service; }

C public Client(@Qualifier(ServiceB.class) Service service) { this.service = service; }

D public Client(@Qualifier("ServiceB") Service service) { this.service = service; }

💡 Hint

Remember @Qualifier requires a string matching the bean name.

The @Qualifier annotation expects a string literal matching the bean name. Option B correctly uses @Qualifier("serviceB"). Options A and C are invalid syntax or wrong type. Option B uses incorrect case.

❓ state_output

advanced

What is printed when injecting with @Qualifier in this example?

Given these beans and injection, what will be printed when client.run() is called?

Spring Boot

@Service("serviceA")
public class ServiceA implements Service {
    public void execute() { System.out.println("Running ServiceA"); }
}

@Service("serviceB")
public class ServiceB implements Service {
    public void execute() { System.out.println("Running ServiceB"); }
}

@Component
public class Client {
    private final Service service;
    public Client(@Qualifier("serviceB") Service service) {
        this.service = service;
    }
    public void run() { service.execute(); }
}

A Running ServiceA

B Compilation error due to missing @Autowired

C No output, NullPointerException occurs

D Running ServiceB

💡 Hint

Look at which bean is injected by @Qualifier and what its execute() method prints.

The @Qualifier("serviceB") injects the ServiceB bean, so calling execute() prints 'Running ServiceB'.

🔧 Debug

advanced

Why does this code cause a NoSuchBeanDefinitionException?

This code tries to inject a bean with @Qualifier("serviceC"), but no such bean exists. What error occurs and why?

Spring Boot

@Service("serviceA")
public class ServiceA implements Service {}

@Service("serviceB")
public class ServiceB implements Service {}

@Component
public class Client {
    private final Service service;
    public Client(@Qualifier("serviceC") Service service) {
        this.service = service;
    }
}

A NullPointerException because service is null.

B NoUniqueBeanDefinitionException because multiple beans exist.

C NoSuchBeanDefinitionException because no bean named 'serviceC' exists.

D BeanCreationException due to circular dependency.

💡 Hint

Check if the bean name in @Qualifier matches any defined bean.

The @Qualifier("serviceC") requests a bean named 'serviceC' which is not defined, causing NoSuchBeanDefinitionException.

🧠 Conceptual

expert

How does @Qualifier help resolve ambiguity in Spring bean injection?

Why is @Qualifier important when multiple beans of the same type exist? Choose the best explanation.

A @Qualifier specifies the exact bean name to inject, resolving ambiguity when multiple beans of the same type exist.

B @Qualifier automatically merges all beans of the same type into a collection for injection.

C @Qualifier disables dependency injection for ambiguous beans to avoid errors.

D @Qualifier renames beans at runtime to avoid conflicts.

💡 Hint

Think about how Spring decides which bean to inject when there are many candidates.

@Qualifier tells Spring exactly which bean to use by name, so it does not get confused when multiple beans of the same type exist.

Practice

1. What is the main purpose of using @Qualifier in Spring Boot?

easy

A. To create a new bean instance automatically

B. To specify which bean to inject when multiple beans of the same type exist

C. To mark a class as a Spring component

D. To configure database connection properties

Solution

1. Step 1: Understand bean ambiguity in Spring

   When multiple beans of the same type exist, Spring cannot decide which one to inject automatically.

2. Step 2: Role of @Qualifier

   @Qualifier explicitly tells Spring which bean to use by specifying its name.

3. Final Answer:

   To specify which bean to inject when multiple beans of the same type exist -> Option B

4. Quick Check:

   @Qualifier = Select specific bean [OK]

Hint: Use @Qualifier to pick one bean among many [OK]

Common Mistakes:

• Thinking @Qualifier creates beans
• Confusing @Qualifier with @Component
• Using @Qualifier for unrelated tasks

2. Which of the following is the correct way to use @Qualifier to inject a bean named "serviceA"?

easy

A. @Autowired @Qualifier(serviceA) private Service service;

B. @Autowired @Qualifier(serviceA) Service service;

C. @Autowired @Qualifier('serviceA') private Service service;

D. @Autowired @Qualifier("serviceA") private Service service;

Solution

1. Step 1: Check syntax for @Qualifier

   @Qualifier requires the bean name as a string literal, so it must be in double quotes.

2. Step 2: Identify correct option

   @Autowired @Qualifier("serviceA") private Service service; uses @Qualifier("serviceA") which is the correct syntax in Java annotations.

3. Final Answer:

   @Autowired @Qualifier("serviceA") private Service service; -> Option D

4. Quick Check:

   String bean name in quotes = correct syntax [OK]

Hint: Always put bean name in double quotes inside @Qualifier [OK]

Common Mistakes:

• Omitting quotes around bean name
• Using single quotes instead of double quotes
• Missing access modifier on field

3. Given the code below, what will be printed when useService() is called?

@Component("serviceA")
class ServiceA implements Service { public String getName() { return "A"; } }
@Component("serviceB")
class ServiceB implements Service { public String getName() { return "B"; } }

@Autowired
@Qualifier("serviceB")
private Service service;

public void useService() {
  System.out.println(service.getName());
}

medium

A. B

B. A

C. serviceB

D. Compilation error

Solution

1. Step 1: Identify injected bean by @Qualifier

   @Qualifier("serviceB") tells Spring to inject the bean named "serviceB", which is ServiceB.

2. Step 2: Check method output

   ServiceB's getName() returns "B", so printing service.getName() outputs "B".

3. Final Answer:

   B -> Option A

4. Quick Check:

   @Qualifier("serviceB") injects ServiceB = prints B [OK]

Hint: Qualifier name matches bean name to pick correct implementation [OK]

Common Mistakes:

• Assuming default bean is injected without @Qualifier
• Confusing bean name with class name
• Expecting compilation error due to multiple beans

4. What is the error in the following code snippet?

@Component("serviceA")
class ServiceA implements Service {}

@Autowired
@Qualifier("serviceB")
private Service service;

medium

A. No bean named 'serviceB' found for injection

B. Missing @Component annotation on Service interface

C. Incorrect use of @Autowired without @Qualifier

D. Service interface cannot be injected

Solution

1. Step 1: Check available beans

   Only a bean named "serviceA" is defined; no bean named "serviceB" exists.

2. Step 2: Effect of @Qualifier("serviceB")

   @Qualifier("serviceB") asks Spring to inject a bean named "serviceB", which is missing, causing an error.

3. Final Answer:

   No bean named 'serviceB' found for injection -> Option A

4. Quick Check:

   @Qualifier name must match existing bean [OK]

Hint: Bean name in @Qualifier must exist in context [OK]

Common Mistakes:

• Assuming interface needs @Component
• Ignoring missing bean name mismatch
• Thinking @Autowired alone resolves ambiguity

5. You have two beans of type PaymentService: @Component("paypalService") and @Component("stripeService"). You want to inject stripeService but only want to use constructor injection. Which is the correct way to do this?

hard

A. public class OrderProcessor {
private PaymentService paymentService;
public OrderProcessor() {}
@Autowired
public void setPaymentService(@Qualifier("stripeService") PaymentService paymentService) {
this.paymentService = paymentService;
}
}

B. public class OrderProcessor {
@Autowired
@Qualifier("stripeService")
private PaymentService paymentService;
}

C. public class OrderProcessor {
private final PaymentService paymentService;
public OrderProcessor(@Qualifier("stripeService") PaymentService paymentService) {
this.paymentService = paymentService;
}
}

D. public class OrderProcessor {
@Autowired
public OrderProcessor(PaymentService paymentService) {
this.paymentService = paymentService;
}
}

Solution

1. Step 1: Understand constructor injection with @Qualifier

   To inject a specific bean via constructor, place @Qualifier on the constructor parameter.

2. Step 2: Identify correct code

   public class OrderProcessor { private final PaymentService paymentService; public OrderProcessor(@Qualifier("stripeService") PaymentService paymentService) { this.paymentService = paymentService; } } correctly uses @Qualifier("stripeService") on the constructor parameter, ensuring the right bean is injected.

3. Final Answer:

   Constructor with @Qualifier on parameter -> Option C

4. Quick Check:

   Constructor param @Qualifier picks bean [OK]

Hint: Put @Qualifier on constructor parameter for constructor injection [OK]

Common Mistakes:

• Using field injection when constructor injection is required
• Missing @Qualifier on constructor parameter
• Confusing setter injection with constructor injection