@Qualifier Annotation Spring Boot erklärt

Die @Qualifier-Annotation in Spring Boot wird verwendet, um Mehrdeutigkeiten aufzulösen, wenn Sie mehrere Beans desselben Typs haben, aber eine bestimmte injizieren möchten. Es hilft Spring zu bestimmen, welche Bean automatisch verdrahtet werden soll, wenn mehrere Kandidaten vorhanden sind.

Hier sind alle gängigen Szenarien, in denen @Qualifier nützlich ist, mit Beispielen:

Szenario 1: Mehrere Bohnen desselben Typs

Möglicherweise haben Sie mehrere Bohnen derselben Sorte und möchten eine bestimmte einspritzen.

Beispiel:

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";
    }
}

Hier implementieren sowohl Hund als auch Katze die Tierschnittstelle.

Verwendung von @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 diesem Beispiel gibt die Annotation @Qualifier("cat") an, dass die Cat-Bean in den AnimalService eingefügt werden soll. Ohne @Qualifier würde Spring aufgrund von Mehrdeutigkeit eine Ausnahme auslösen.

Szenario 2: Verwendung von @Qualifier mit primären und sekundären Beans

Manchmal haben Sie möglicherweise eine „primäre“ Bohne und andere, die weniger häufig verwendet werden, möchten aber trotzdem die spezifischen Bohne mit @Qualifier injizieren können.

Beispiel:

@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";
    }
}

Die @primary-Annotation stellt sicher, dass Dog standardmäßig injiziert wird. Sie können jedoch weiterhin @Qualifier verwenden, um Cat.

einzufügen

Verwendung von @Qualifier zum Überschreiben von @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 diesem Fall wird die Cat-Bean aufgrund der @Qualifier-Annotation injiziert, obwohl Dog als @primary markiert ist.

Szenario 3: @Qualifier mit Konstruktorinjektion und Feldinjektion
@Qualifier kann sowohl mit konstruktorbasierter als auch mit feldbasierter Injektion verwendet werden.

Beispiel: Feldinjektion mit @Qualifier:

@Service
public class AnimalService {

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

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

In diesem Fall stellt der @Qualifier("dog") sicher, dass die Dog-Bean in den AnimalService eingefügt wird.

Szenario 4: @Qualifier mit Methodenparameterinjektion

Sie können @Qualifier auch verwenden, wenn Sie Abhängigkeiten über Methodenparameter einfügen.

Beispiel:

@Service
public class AnimalService {

    private Animal animal;

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

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

Hier stellt @Qualifier("dog") sicher, dass die Dog-Bean über die Setter-Methode injiziert wird.

Szenario 5: @Qualifier mit benutzerdefinierten Anmerkungen

Sie können benutzerdefinierte Qualifizierer erstellen, um die Festcodierung von Bean-Namen zu vermeiden und so den Code sauberer und wartbarer zu machen.

Beispiel: Benutzerdefinierter Qualifizierer:
Erstellen Sie einen benutzerdefinierten 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 {
}

Wenden Sie den benutzerdefinierten Qualifier an:

@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";
    }
}

Injizieren Sie mit dem benutzerdefinierten Qualifizierer:

@Service
public class AnimalService {

    private final Animal animal;

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

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

In diesem Beispiel wird @DogQualifier verwendet, um anzugeben, welche Bohne injiziert werden soll, anstatt @Qualifier("dog") zu verwenden.

Szenario 6: @Qualifier in Sammlungen

Sie können @Qualifier beim automatischen Verdrahten einer Bohnensammlung verwenden, um sicherzustellen, dass nur bestimmte Bohnen injiziert werden.

Beispiel:

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";
    }
}

Verwendung mit einer Sammlung:

@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()));
    }
}

</animal></animal>

In diesem Beispiel werden nur Hunde- und Katzenbohnen injiziert, da sie mit dem @Qualifier("domestic") markiert sind.

Zusammenfassung:

@Qualifier hilft bei der Injektion bestimmter Bohnen, wenn es mehrere Kandidaten desselben Typs gibt.

Es wird in Szenarien wie Konstruktorinjektion, Feldinjektion, Methodeninjektion, benutzerdefinierten Qualifizierern und sogar mit Sammlungen verwendet.

Wenn Sie diese Szenarien verstehen, können Sie @Qualifier effektiv nutzen, um Mehrdeutigkeiten aufzulösen und die Bean-Injektion in einer Spring Boot-Anwendung zu verwalten.

Das obige ist der detaillierte Inhalt von@Qualifier Annotation Spring Boot erklärt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!