@Qualifier for ambiguous beans in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to inject a specific bean using @Qualifier.

Spring Boot

@Autowired
@Qualifier("paymentService")
private Service [1];

Drag options to blanks, or click blank then click option'

AService

Bservice

CpaymentService

Dbean

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name instead of the bean name.

Using a generic variable name that causes ambiguity.

You need to specify the exact bean name to resolve ambiguity using @Qualifier or bean name injection.

2fill in blank

medium

Complete the annotation to specify which bean to inject.

Spring Boot

@Autowired
@Qualifier("[1]")
private Service service;

Drag options to blanks, or click blank then click option'

ApaymentService

Bservice

CService

Dbean

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the quotes around the bean name.

Using the class name instead of the bean name.

The @Qualifier annotation requires the exact bean name as a string to resolve ambiguity.

3fill in blank

hard

Fix the error in the injection by adding the correct annotation.

Spring Boot

@Autowired
[1]
private Service service;

Drag options to blanks, or click blank then click option'

ApaymentService

Bbean

Cservice

D@Qualifier("paymentService")

Attempts:

3 left

💡 Hint

Common Mistakes

Only renaming the variable without @Qualifier.

Using @Qualifier without specifying the bean name.

To fix ambiguity, you must add @Qualifier with the bean name above the field or on the field declaration.

4fill in blank

hard

Fill both blanks to declare and inject the correct bean using @Qualifier.

Spring Boot

@Autowired
@Qualifier("[1]")
private [2] service;

Drag options to blanks, or click blank then click option'

ApaymentService

BOrderService

CUserService

Dservice

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing bean names and class types incorrectly.

Using a generic class type that does not match the bean.

You specify the bean name in @Qualifier and the correct service class type for the variable.

5fill in blank

hard

Fill all three blanks to define two beans and inject one using @Qualifier.

Spring Boot

@Bean
public [1] [2]() {
    return new [1]();
}

@Autowired
@Qualifier("[2]")
private [1] service;

Drag options to blanks, or click blank then click option'

APaymentService

BpaymentService

COrderService

DorderService

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for bean and qualifier.

Mismatching class type and bean name.

Define a bean method with the class and bean name, then inject it using @Qualifier with the bean name.

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