@Qualifier in Spring: What It Is and How to Use It

@Qualifier is a Spring annotation used to resolve conflicts when multiple beans of the same type exist. It tells Spring exactly which bean to inject by specifying a name or qualifier value.

How It Works

Imagine you have several friends who can help you with a task, but you want to ask a specific one. In Spring, when you have multiple beans of the same type, the framework gets confused about which one to use. @Qualifier acts like giving a name tag to each friend so you can call the right one.

When Spring sees @Qualifier on a field or constructor parameter, it looks for the bean with the matching name or qualifier value and injects that specific bean. This avoids errors and makes your code clear about which bean is needed.

Example

This example shows two beans of the same type and how @Qualifier selects the right one for injection.

java

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

interface GreetingService {
    String greet();
}

@Component
@Qualifier("english")
class EnglishGreetingService implements GreetingService {
    public String greet() {
        return "Hello!";
    }
}

@Component
@Qualifier("spanish")
class SpanishGreetingService implements GreetingService {
    public String greet() {
        return "¡Hola!";
    }
}

@Service
class Greeter {
    private final GreetingService greetingService;

    public Greeter(@Qualifier("spanish") GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void sayHello() {
        System.out.println(greetingService.greet());
    }
}

// In a Spring Boot application, running Greeter.sayHello() prints:
// ¡Hola!

Output

¡Hola!

When to Use

Use @Qualifier when you have more than one bean of the same type and Spring cannot decide which one to inject. This often happens when you have multiple implementations of an interface or different configurations of the same class.

For example, if you have different payment processors or message senders, you can use @Qualifier to specify which one to use in each case. It helps keep your code organized and avoids errors during startup.

Key Points

• @Qualifier resolves ambiguity when multiple beans of the same type exist.
• It works by specifying a name or qualifier value to select the correct bean.
• Use it on constructor parameters, fields, or method parameters where injection happens.
• It improves code clarity and prevents Spring injection errors.

Key Takeaways

@Qualifier tells Spring which bean to inject when multiple beans share the same type.

Use @Qualifier to avoid conflicts and make your dependency injection explicit.

It works by matching the qualifier name with the bean's name or qualifier annotation.

Apply @Qualifier on constructor parameters, fields, or methods where injection occurs.