Spring – Injection de dépendance (@Autowired, @Qualifier & @Ressource)

Spring – Injection de dépendance (@Autowired, @Qualifier & @Ressource)

Hello les amis, dans ce tuto nous allons voir comment faire l’injection de dépendance en utilisant l’annotation @Autowired, pour plus de detail sur le DI(Injection de dépendance) je vous invite mes amis d’aller voir ce lien.

1 –  @Autowired :

C’est une annotation qui nous permet de faire l’injection de dépendances entre les beans de l’application (Spring va tout faire), il suffit juste d’annoter un constructeur ou une méthode avec cette dernière. et le conteneur Spring va faire la suite(La creation du bean, le chercher et l’injecter automatiquement…).

  •  Pour bien comprendre le principe je vous propose de faire un petit exemple :

On va utiliser le principe du couplage faible “ne pas avoir beacoup de dépendance entre les classes de votre applicaion ce qui rend la maintenance de ce tte dernière facile”, donc on va créer une classe dao et une interface idao puis une classe metier qui va accéder à la partie dao en utilisant que l’interface :

Donc maintenant, on va créer la classe Metier et utiliser le principe de DI :

Donc, mtn une fois le conteneur Spring se lance, il va crée l’instance de la classe Dao et la classe Metier(Principe Ioc), et il va faire l’injection de dépendance (injecter l’objet créeé de la classe Dao dans la propriété de l’interface IDao qui existe dans la classe Metier)

  • Quelques remarques à retenir :

la valeur par défaut de l’annotation @Autowired est true, ca veut dire qu’il faut obligatoirement initialiser le bean à injecter, si le Conteneur Spring ne trouve pas le bean une exception de type BeanCreationException est levée, on peut bien sur modifier cette annotation en mettant la valeur à false comme suit :

@Autowired(required=false).

Le  conteneur spring va lever des exceptions de type BeanCreationException dans le deux cas suivant :

– Si @Autowired ne trouve aucun bean correspondant au type de l’entité annoté sauf si l’attribut requierd est false.

– Si @Autowired trouve plusieurs beans correspondants au type annoté et que l’élément n’est pas un tableau ou collection.

2 – @Qualifier :

A côté de l’annotation @Autowired, on peut utiliser d’autres annotations pour nous faciliter la vie :D, nous allons voir les annotations @Qualifier & @Ressource

@Qualifier : c’est une annotation utilisée lorsqu’on a plusieurs classes qui implémentent une interface, et on veux faire l’injection des dépendances en utilisant cet interface.

  • Un petit exemple pour bien comprendre :

Dans une seule application , on a une interface IDao qui sera implémentée par 3 classes : DaoJdbc, DaoHibernate, DaoSpringData.

La déclaration des 3 classes :

Dans la partie Métier on a une classe qui va utiliser la partie Dao(pour respecter la principe du couplage faible on va utiliser l’interface IDao) :

Donc puisqu’on 3 classes qui implémentent cette interface, on doit utiliser un truc pour spécifier à la partie métier quelle classe doit utiliser (utilisation de l’annotation Qualifier).

@Qualifier est utilisée donc pour montrer au Conteneur Spring la classe à injecter (dans le cas de plusieurs classes).

2 – @Resource:

L’annotation @Resource : on peut dire qu’elle s’agit d’une fusion entre l’annotation @Autowired et @Qualifier, ci-dessous un petit exemple :

On va utiliser l’exemple précèdent, ci-dessous la déclaration des 3 classes :

Vous avez remarqué qu’il n’ y a aucun changement au niveau de la première partie, par contre dans la partie Métier on a une classe qui va utiliser la partie Dao(pour respecter la principe du couplage faible on va utiliser l’interface IDao) :

Donc comme vous voyez au lieu d’utiliser deux annotation @Autowired et @Qualifier on utilise @Resource

 

 

 

Injection de dépendance – Par Constructeur

Injection de dépendance – Par Constructeur :

Dans ce tuto, nous allons voir les différentes maniere pour faire une injection de dépendance par Constructeur.

    • Injecter une variable Primitive :
      Nous allons créer une classe Personne.java qui va contenir 2 variables (id et nom), trois constructeurs et une methode, ci-dessous le code source

      Nous allons maintenant créer le fichier applicationContexte.xml, c’est au niveau de ce fichier que nos objets seront créés ainsi que leur injection.

      L’injection dans ce cas se fait par un Constructeur, donc on va utiliser constructor-arg

      En fin, nous allons créer la classe d’exécution :

      Résultats :

    • Injecter un Objet :
      Dans le cas ou on a une relation entre deux classes une relation de type HAS-A, du coup nous avons besoin de créer l’instance de la classe B pour la faire passer au constructeur de la classe A.Nous allons prendre l’exemple d’une personne qui a une adresse.(Personne Has-A Adresse)Adresse.java :
      Nous pouvons injecter des valeurs de collections en utilisant un constructeur, trois éléments peuvent être utilisés dans le tag <constructeur-arg> : List, Set, Map. Puisque les trois éléments sont utilisés de la même manière nous allons faire l’exemple de List.Personne.java :

      applicationContext.xml :


      Classe d’éxecution(Main.java) :


       
    • Injecter une collection :
      Nous pouvons injecter des valeurs de collections en utilisant un constructeur, trois éléments peuvent être utilisés dans le tag <constructeur-arg> : List, Set, Map. Puisque les trois éléments sont utilisés de la même manière nous allons faire l’exemple de List.Dans ce cas nous allons utiliser la classe Client, un client peut passer plusieurs commandes :Client.java :

      applicationContext.xml :

      Classe d’éxecution(Main.java) :

       


       

       

       

Spring – Injection de dépendance(DI)

Spring – Injection de dépendance(DI) :

L’injection de dépendance(DI) est un design pattern qui nous permet de supprimer les dépendances entre les objets et de faire l’injection automatiquement lors du démarage du conteneur Spring, ce dernier facilite la gestion de l’appli, test et maintenance de l’application, le couplage du code est faible, donc on peut changer dans l’application sans faire bcp de modifications dans le code.

Les informations seront fournies depuis un fichier xml.

Nous avons deux façons pour faire l’injection de dépendance :

 

Integration du framework Spring avec Hibernate

Integration du framework Spring avec Hibernate :

On peut facilement integrer spring avec hibernate, dans ce cas on n’aura pas besoin de créer le fichier hibernate.cfg.xml(c’est le fichier qui contient les informations de connexion avec la base de donnée ), toutes ces configurations seront intégrées dans le fichier applicationContext.xml.

L’avantage d’utiliser Spring avec Hibernate :

Spring fournit une classe qui s’appele HibernateTemplate, qui nous permet en fait de créer la configuration, BuildSessionFactory, Session, commencer et commiter les transactions etc…, donc puisque tout ce que nous venons de dire sera géré automatiquement, du coup on aura pas besoin d’écrire bcp de lignes de code.

7 étapes à suivre pour réussir l’intégration du Spring et Hibernate :

  1. Créer la base de donnée.
  2. Importer les jars necessaires.
  3. Créer la classe java beans
  4. Créer le fichier de mapping (.hbm.xml)
  5. Créer la classe qui va intéragir avec la base de donnée
  6. Créer le fichier applicationContext.xml.
  7. Créer la classe exécution.

Ci-dessous la description de chaque étape.

  1. Créer la base de donnée :
    Nous allons utiliser MySql comme SGBD, ci-dessous le script à utiliser pour créer la table personne.
  2. Importation des jars :
    Vous pouvez telecharger la version souhaitée.
  3. Créer la classe java beans :
    Nous allons créer une classe javabeans qu’on va la nommer Personne.java, ci-dessous le code :
  4. Création du fichier de mapping (.hbm.xml) :
    Ce fichier nous permet de faire en fait la liason entre les attributs de la classe et les champs de la table c’est ce qu’on appele le mapping.
  5. Creation de la classe DAO :
    c’est avec cette classe qu’on peut mettre en place nous méthode pour faire des mises à jour à une base de donnée.

    Donc comme vous voyez la classe HibernateTemplate à déjà des methodes qui sont prédefinies. Donc HibernateTemplate nous permet de faire tous ces trucs en écrivant un peu de code c’est wow n’est ce pas !!
  6. Creation du fichier applicationContext.xml :
    c’est au niveau de ce fichier qu’on va faire presque toute la config du projet : connexion avec base de donnée, création des objet(en se basent sur IOC), injection des depandances, etc…
  7. Exécution du projet :
    on va créer une classe qui va prendre en charge l’exécution de notre projet.

    Pour bien comprendre le pricipe d’IOC je vous invite à voir ce tuto Spring.

Conteneur IOC

Le conteneur IOC est au cœur du framework Spring. Il est responsable d’instancier, configurer et assembler les objets, gérer leur cycle de vie complet de la création jusqu’à la destruction. Il utilise l’injection de dépendance (DI) pour gérer les éléments qui composent une application.

Le conteneur reçoit les instructions sur les objets à instancier, configurer, assembler par la lecture des métadonnées de configuration fournis. Les métadonnées de configuration peut être représentées soit par XML, annotations Java, ou un code Java. Le schéma ci-dessous est une vue de haut niveau de la façon dont fonctionne Spring. Le conteneur Spring IoC rend l’utilisation des classes Java POJO et les métadonnées de configuration pour produire un système ou une application entièrement configurée et exécutable.

container-ioc

Il existe deux types de conteneurs IOC :

  • BeanFactory : Interface qui existe dans la package org.springframework.beans.factory.BeanFactory
  • ApplicationContext : Interface qui existe dans la package org.springframework.context.ApplicationContext

Différence entre BeanFactory & ApplicationContext :

BeanFactory et ApplicationContext sont des interfaces qui agissent comme des conteneurs IoC.

L’interface ApplicationContext est construite au-dessus de l’interface BeanFactory. Il ajoute quelques fonctionnalités supplémentaires que BeanFactory tels que l’intégration simple avec l’AOP de Spring, la couche application contexte spécifique (par exemple WebApplicationContext) pour les applications Web. Il est donc préférable d’utiliser ApplicationContext que BeanFactory.