Différence entre Annotation SpringBoot: @Qualifier et @Autowired

Pour les classes que nous développons pour notre application, il est plus simple d’utiliser des annotations . Ces annotations est plus intrusive puisqu’il faut les ajouter dans le code source des classes de nos beans.

• @Autowired
• @Primary
• @Qualifier
• @Value

Le Spring Framework autorise à mêler cette approche avec l’utilisation de méthodes de fabrique. Cela laisse donc une liberté complète aux développeurs pour définir leur contexte d’application.

Dans le monde de Spring Framework, la gestion des dépendances est un aspect fondamental de la création d’applications robustes et maintenables. Spring propose deux annotations principales pour faciliter l’injection de dépendances : @Autowired et @Qualifier. Comprendre quand et comment utiliser ces annotations est crucial pour unr configuration efficace des beans. @Autowired et @Qualifier sont tous deux des annotations utilisées dans Spring Framework pour travailler avec l’injection de dépendances, mais elles sont utiles pour d’autres besoins.

Qu’est-ce que l’injection de dépendances dans Spring ?

L’injection de dépendances est un modèle de conception utilisé dans le développement de logiciels et joue un rôle important dans Spring Framework, qui est un cadre populaire pour la création d’applications d’entreprise basées sur Java. L’injection de dépendances est une technique dans laquelle un objet fournit les dépendances d’un autre objet. En d’autres termes, il s’agit d’un moyen d’obtenir une inversion de contrôle (IoC), dans laquelle le contrôle du flux d’exécution d’un programme est transféré du programme lui-même vers un framework ou un conteneur.

Dans le contexte de Spring, l’injection de dépendances est utilisée pour gérer les dépendances entre différents composants d’une application, tels que les classes, les beans ou les services. Spring fournit un conteneur (souvent appelé « conteneur Spring IoC ») chargé d’instancier, de configurer et de gérer ces objets. Le conteneur injecte les dépendances requises dans les objets au moment de l’exécution, vous permettant de créer des applications faiblement couplées et hautement maintenables.

Comment fonctionne l’injection de dépendances dans Spring ?

• Composants : dans une application Spring, vous définissez généralement divers composants, tels que des classes ou des beans, qui représentent différentes parties des fonctionnalités de votre application.
• Dépendances : ces composants ont souvent des dépendances vis-à-vis d’autres composants ou services pour effectuer leurs tâches efficacement.
• Configuration : vous configurez votre application Spring à l’aide de fichiers de configuration basés sur XML, d’annotations Java ou de classes de configuration basées sur Java (à l’aide des annotations @Configuration et @Bean).
• Injection : le conteneur IoC de Spring gère la création des objets et de leurs dépendances. Lorsqu’un composant a besoin d’une dépendance, le conteneur l’injecte au moment de l’exécution, garantissant que les objets requis sont disponibles et correctement initialisés.

Il existe deux manières principales d’effectuer l’injection de dépendances dans Spring:

• Injection de constructeur : les dépendances sont injectées via le constructeur de la classe dépendante. Il s’agit de l’approche la plus courante et recommandée car elle garantit que l’objet dépendant est entièrement initialisé lors de sa création.
• Injection Setter : les dépendances sont injectées via des méthodes setter dans la classe dépendante. Bien que cette méthode est moins utilisé que la première, l’injection de setter peut être utile dans les scénarios où vous avez des dépendances facultatives ou si vous souhaitez modifier les dépendances au moment de l’exécution.

L’exemple ci-dessous montre l’injection de dépendances de Java Spring :

public class SampleApp { 
    private CricbuzzService cricbuzzService; 
  
    // Injection par consructeur 
    public SampleApp(CricbuzzService cricbuzzService) { 
        this.cricbuzzService = cricbuzzService; 
    } 
  
    public void run() { 
        myService.doWhatever(); 
    } 
} 
  
public interface SampleService { 
    void doWhatever(); 
} 
  
public class SampleServiceImpl implements SampleService { 
    @Override
    public void doWhatever() { 
        System.out.println("faire quelque chose dans  SampleServiceImpl."); 
    } 
}

Injection de dépendances avec @Autowired

L’annotation @Autowired est utilisé pour injecter automatiquement des dépendances dans une classe. Lorsque vous annotez un champ, une méthode setter ou un constructeur avec @Autowired, Spring tentera de trouver un bean correspondant dans le contexte de l’application et de l’injecter dans le composant annoté. Il est généralement utilisé lorsque vous avez plusieurs beans du même type et que Spring doit déterminer lequel injecter automatiquement.

@Service
public class MonService { 
    private final MaRepository repository; 
  
    @Autowired public MonService(MaRepository repository) 
    { 
        this.repository = repository; 
    } 
}

Définition de @Qualifier

L’annotation @Qualifier est utilisé conjointement avec @Autowired pour spécifier quel bean exact doit être injecté lorsqu’il existe plusieurs beans du même type dans le contexte de l’application. Vous utilisez @Qualifier pour fournir un nom ou une valeur de bean spécifique pour indiquer quel bean doit être injecté.

@Service
public class MonService { 
    private final MaRepository premiereRepository; 
    private final MaRepository secondRepository; 
  
    @Autowired
    public MonService(@Qualifier("premiereRepository") 
                     MaRepository premiereRepository, 
                     @Qualifier("secondRepository") 
                     MaRepository secondRepository) 
    { 
        this.premiereRepository = premiereRepository; 
        this.secondRepository = secondRepository; 
    } 
} 

Différences majeures entre les annotations @Autowired et @Qualifier

Quand utiliser @Autowired et @Qualifier ?

Vous devez utiliser @Autowired et @Qualifier dans les applications Spring dans des circonstances spécifiques :

Utilisation de @Autowired :

L’utilisation de @Autowired est utilisé lorsque vous souhaitez que Spring injecte automatiquement une dépendance dans une classe sans spécifier explicitement le nom du bean. C’est particulièrement utile lorsqu’il n’y a qu’un seul bean d’un type spécifique dans le contexte de l’application, ou lorsque vous souhaitez injecter le bean principal de ce type.

@Autowired
private SomeService someService;

Il simplifie la configuration en permettant à Spring de choisir le bean approprié à injecter en fonction du type.

Utilisation de @Autowired avec @Qualifier :

L’utilisation de @Autowired en combinaison avec @Qualifier lorsqu’il existe plusieurs beans du même type dans le contexte de l’application et que vous devez spécifier lequel injecter. @Qualifier vous permet de fournir un nom ou une valeur de bean spécifique pour indiquer quel bean doit être injecté.

@Autowired
@Qualifier("specificBeanName") 
private SomeService someService;

Utiliser @Autowired dans les constructeurs :

C’est une bonne pratique d’utiliser @Autowired pour indiquer l’injection de dépendances basée sur le constructeur. Cela peut rendre votre code plus lisible et plus facile à tester.

@Autowired
public MyComponent(SomeService someService) { 
    this.someService = someService; 
}

C’est quoi l’annotation @Primary ?

L’annotation @Primary permet d’indiquer au conteneur le bean qui devra être sélectionné en priorité en cas d’ambiguïté.

@Bean
@Primary
public Runnable oneTask() {
  // ...
}

@Bean
public Runnable anotherTash() {
  // ...
}

A quoi sert l’annotation @Value ?

L’annotation @Value est utilisable sur un attribut ou un paramètre pour un type primitif ou une chaîne de caractères. Elle donne la valeur par défaut à injecter. Cette annotation devient très utile pour résoudre des dépendances de manière plus souple ou pour lire des données depuis un fichier de configuration.

public class SampleDev {

  @Value("Bonjour!")
  private String value;

  @Override
  public String get() {
    return value;
  }

}

Conclusion

En résumé, @Autowired sert à l’injection automatique de dépendances, tandis que @Qualifier sert à spécifier quel bean exact injecter lorsqu’il existe plusieurs beans du même type. Choisissez l’annotation appropriée en fonction de votre cas d’utilisation spécifique et de la complexité de la configuration du bean de votre application Spring.

// on the below line creating a class for Dog. 
@Component
public class Dog { 

    // on the below line creating a string variable for dog 
    // breed. 
    private String dogBreed; 

    // on the below line creating a constructor. 
    public Dog(String breed) { this.dogBreed = breed; } 
    // on the below line creating a getter method. 
    public String getdogBreed() { return dogBreed; } 
} 
// on the below line creating a class for German Sheapered 
// and annotating it with Primary annotation. 
@Component
@Primary
public class GermanShepared extends Dog { 
    // on the below line creting a constructor and passing 
    // breed type. 
    public GermanShepared() { super("GermanShepared"); } 
} 

// on the below line creating a class for LabraDog. 
@Component
public class LabraDog extends Dog { 
    // on the below line creting a constructor and passing 
    // breed type. 
    public LabraDog() { super("LabraDog"); } 
}