Explication du démarrage à ressort de l'annotation @Qualifier

L'annotation @Qualifier dans Spring Boot est utilisée pour résoudre l'ambiguïté lorsque vous avez plusieurs beans du même type mais que vous souhaitez en injecter un spécifique. Cela aide Spring à déterminer quel bean doit être automatiquement câblé lorsque plusieurs candidats existent.

Voici tous les scénarios courants dans lesquels @Qualifier est utile avec des exemples :

Scénario 1 : plusieurs beans du même type

Vous pouvez avoir plusieurs beans du même type et vous souhaitez en injecter un spécifique.

Exemple :

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

Ici, Chien et Chat implémentent l'interface Animal.

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

Dans cet exemple, l'annotation @Qualifier("cat") spécifie que le bean Cat doit être injecté dans AnimalService. Sans @Qualifier, Spring lèverait une exception en raison d'une ambiguïté.

Scénario 2 : Utilisation de @Qualifier avec des beans primaires et secondaires

Parfois, vous pouvez avoir un bean "primaire" et d'autres qui sont moins fréquemment utilisés, mais vous souhaitez quand même pouvoir injecter les spécifiques avec @Qualifier.

Exemple :

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

L'annotation @primary garantit que Dog est injecté par défaut. Mais vous pouvez toujours utiliser @Qualifier pour injecter Cat.

Utilisation de @Qualifier pour remplacer @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();
    }
}

Dans ce cas, bien que Dog soit marqué comme @primary, le haricot Cat est injecté en raison de l'annotation @Qualifier.

Scénario 3 : @Qualifier avec injection de constructeur et injection de champ
@Qualifier peut être utilisé avec une injection basée sur le constructeur et sur le terrain.

Exemple : Injection de champ avec @Qualifier :

@Service
public class AnimalService {

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

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

Dans ce cas, le @Qualifier("dog") s'assure que le haricot Dog est injecté dans l'AnimalService.

Scénario 4 : @Qualifier avec injection de paramètres de méthode

Vous pouvez également utiliser @Qualifier lors de l'injection de dépendances via des paramètres de méthode.

Exemple :

@Service
public class AnimalService {

    private Animal animal;

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

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

Ici, @Qualifier("dog") garantit que le haricot Dog est injecté via la méthode setter.

Scénario 5 : @Qualifier avec annotations personnalisées

Vous pouvez créer des qualificatifs personnalisés pour éviter de coder en dur les noms de beans, ce qui rend le code plus propre et plus maintenable.

Exemple : Qualificateur personnalisé :
Créez un qualificatif personnalisé :

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

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

Appliquer le qualificatif personnalisé :

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

Injecter à l'aide du qualificatif personnalisé :

@Service
public class AnimalService {

    private final Animal animal;

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

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

Dans cet exemple, @DogQualifier est utilisé pour spécifier quel bean injecter, au lieu d'utiliser @Qualifier("dog").

Scénario 6 : @Qualifier dans les collections

Vous pouvez utiliser @Qualifier lors du câblage automatique d'une collection de beans pour vous assurer que seuls des beans spécifiques sont injectés.

Exemple :

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

Utilisation avec une 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()));
    }
}

Dans cet exemple, seuls les haricots Dog et Cat sont injectés car ils sont marqués du @Qualifier("domestic").

Résumé :

@Qualifier aide à injecter des beans spécifiques lorsqu'il existe plusieurs candidats du même type.

Il est utilisé dans des scénarios tels que l'injection de constructeur, l'injection de champ, l'injection de méthode, les qualificatifs personnalisés et même avec des collections.

En comprenant ces scénarios, vous pouvez utiliser @Qualifier efficacement pour résoudre les ambiguïtés et gérer l'injection de bean dans une application Spring Boot.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!