首页 > Java > java教程 > 正文

@Qualifier Annotation Spring Boot Explained

Patricia Arquette
发布: 2024-09-22 18:17:32
原创
1066 人浏览过

@Qualifier Annotation Spring Boot Explained

The @Qualifier annotation in Spring Boot is used to resolve ambiguity when you have multiple beans of the same type but want to inject a specific one. It helps Spring determine which bean should be autowired when multiple candidates exist.

Here are all the common scenarios where @Qualifier is useful with examples:

Scenario 1: Multiple Beans of the Same Type

You may have multiple beans of the same type, and you want to inject a specific one.

Example:

import org.springframework.stereotype.Component;

@Component
public class Dog implements Animal {
    @Override
    public String sound() {
        return "Bark";
    }
}

@Component
public class Cat implements Animal {
    @Override
    public String sound() {
        return "Meow";
    }
}

登录后复制

Here, both Dog and Cat implement the Animal interface.

Usage of @Qualifier:

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

@Service
public class AnimalService {

    private final Animal animal;

    @Autowired
    public AnimalService(@Qualifier("cat") Animal animal) {
        this.animal = animal;
    }

    public String getAnimalSound() {
        return animal.sound();
    }
}

登录后复制

In this example, the @Qualifier("cat") annotation specifies that the Cat bean should be injected into the AnimalService. Without @Qualifier, Spring would throw an exception due to ambiguity.

Scenario 2: Using @Qualifier with Primary and Secondary Beans

Sometimes, you may have one "primary" bean and others that are less frequently used, but you still want to be able to inject the specific ones with @Qualifier.

Example:

@Component
@Primary
public class Dog implements Animal {
    @Override
    public String sound() {
        return "Bark";
    }
}

@Component
public class Cat implements Animal {
    @Override
    public String sound() {
        return "Meow";
    }
}

登录后复制

The @primary annotation ensures that Dog is injected by default. But you can still use @Qualifier to inject Cat.

Usage of @Qualifier to Override @primary:

@Service
public class AnimalService {

    private final Animal animal;

    @Autowired
    public AnimalService(@Qualifier("cat") Animal animal) {
        this.animal = animal;
    }

    public String getAnimalSound() {
        return animal.sound();
    }
}

登录后复制

In this case, despite Dog being marked as @primary, the Cat bean is injected due to the @Qualifier annotation.

Scenario 3: @Qualifier with Constructor Injection and Field Injection
@Qualifier can be used with both constructor-based and field-based injection.

Example: Field Injection with @Qualifier:

@Service
public class AnimalService {

    @Autowired
    @Qualifier("dog")
    private Animal animal;

    public String getAnimalSound() {
        return animal.sound();
    }
}

登录后复制

In this case, the @Qualifier("dog") ensures that the Dog bean is injected into the AnimalService.

Scenario 4: @Qualifier with Method Parameter Injection

You can also use @Qualifier when injecting dependencies via method parameters.

Example:

@Service
public class AnimalService {

    private Animal animal;

    @Autowired
    public void setAnimal(@Qualifier("dog") Animal animal) {
        this.animal = animal;
    }

    public String getAnimalSound() {
        return animal.sound();
    }
}

登录后复制

Here, @Qualifier("dog") ensures that the Dog bean is injected through the setter method.

Scenario 5: @Qualifier with Custom Annotations

You can create custom qualifiers to avoid hardcoding bean names, making the code cleaner and more maintainable.

Example: Custom Qualifier:
Create a Custom Qualifier:

import org.springframework.beans.factory.annotation.Qualifier;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface DogQualifier {
}

登录后复制

Apply the Custom Qualifier:

@Component
@DogQualifier
public class Dog implements Animal {
    @Override
    public String sound() {
        return "Bark";
    }
}

@Component
public class Cat implements Animal {
    @Override
    public String sound() {
        return "Meow";
    }
}

登录后复制

Inject Using the Custom Qualifier:

@Service
public class AnimalService {

    private final Animal animal;

    @Autowired
    public AnimalService(@DogQualifier Animal animal) {
        this.animal = animal;
    }

    public String getAnimalSound() {
        return animal.sound();
    }
}

登录后复制

In this example, @DogQualifier is used to specify which bean to inject, instead of using @Qualifier("dog").

Scenario 6: @Qualifier in Collections

You can use @Qualifier when autowiring a collection of beans to ensure that only specific beans are injected.

Example:

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

@Component
@Qualifier("domestic")
public class Dog implements Animal {
    @Override
    public String sound() {
        return "Bark";
    }
}

@Component
@Qualifier("domestic")
public class Cat implements Animal {
    @Override
    public String sound() {
        return "Meow";
    }
}

@Component
public class Lion implements Animal {
    @Override
    public String sound() {
        return "Roar";
    }
}

登录后复制

Usage with a Collection:

@Service
public class AnimalService {

    private final List<Animal> animals;

    @Autowired
    public AnimalService(@Qualifier("domestic") List<Animal> animals) {
        this.animals = animals;
    }

    public void printAnimalSounds() {
        animals.forEach(animal -> System.out.println(animal.sound()));
    }
}

登录后复制

In this example, only Dog and Cat beans are injected because they are marked with the @Qualifier("domestic").

Summary:

@Qualifier helps in injecting specific beans when there are multiple candidates of the same type.

It is used in scenarios like constructor injection, field injection, method injection, custom qualifiers, and even with collections.

By understanding these scenarios, you can use @Qualifier effectively to resolve ambiguity and manage bean injection in a Spring Boot application.

以上是@Qualifier Annotation Spring Boot Explained的详细内容。更多信息请关注PHP中文网其他相关文章!

来源:dev.to
本站声明
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
作者最新文章
热门教程
更多>
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责声明 Sitemap
PHP中文网:公益在线PHP培训,帮助PHP学习者快速成长!