@Qualifier for ambiguous beans in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What problem does the @Qualifier annotation solve in Spring Boot?

It helps Spring know which bean to inject when there are multiple beans of the same type, avoiding confusion.

beginner

How do you use @Qualifier to specify a bean named 'serviceA' for injection?

You add @Qualifier("serviceA") above the injection point, like:
@Autowired
@Qualifier("serviceA")
private MyService service;

beginner

True or False: @Qualifier can be used with constructor injection, setter injection, and field injection.

True. @Qualifier works with all types of dependency injection to specify which bean to use.

beginner

What happens if you have two beans of the same type but do NOT use @Qualifier when injecting?

Spring throws an error because it doesn't know which bean to pick. This is called an ambiguous bean error.

intermediate

Can @Qualifier be combined with @Primary? How do they work together?

Yes. @Primary marks a default bean to use if no @Qualifier is specified. But if @Qualifier is used, it overrides @Primary.

What does @Qualifier do in Spring Boot?

A Specifies which bean to inject when multiple beans of the same type exist

B Marks a bean as the primary bean

C Creates a new bean instance

D Disables bean injection

@Qualifier tells Spring exactly which bean to use when there are multiple candidates.

If you have two beans of type Service, how do you avoid ambiguity?

A Use @ComponentScan

B Use @Autowired only

C Use @Qualifier to name the bean to inject

D Remove one bean

Using @Qualifier specifies which bean Spring should inject, avoiding ambiguity.

Which of these is a correct way to use @Qualifier with constructor injection?

A public MyClass(MyService service) {}

B @Qualifier("bean1") public MyClass(MyService service) {}

C public MyClass(MyService service) {@Qualifier("bean1")}

D public MyClass(@Qualifier("bean1") MyService service) {}

You place @Qualifier on the constructor parameter to specify the bean.

What annotation marks a bean as the default when no @Qualifier is used?

A @Primary

B @Default

C @Qualifier

D @Autowired

@Primary marks a bean as the default choice if no @Qualifier is specified.

If a bean is marked with @Primary and another bean is injected with @Qualifier, which bean is used?

A The @Primary bean

B The bean specified by @Qualifier

C Both beans

D Injection fails

@Qualifier overrides @Primary and selects the specified bean.

Explain why @Qualifier is important when you have multiple beans of the same type in Spring Boot.

Think about how Spring chooses beans when there are many options.

Describe how you would use @Qualifier in a Spring Boot project with two implementations of the same interface.

Consider how to tell Spring which version to use.

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