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 – Méthode Setter

Injection de dépendance – Méthode Setter :

Dans ce tuto, nous allons voir comment faire une injection de dépendance en utilisant la méthode setter :

  • Injecter une variable primitive :
    Nous allons créer une classe Personne.java qui va contenir 2 variables (id et nom) et leurs méthodes setter et getterPersonne.java :


    applicationContext.xml :


    Classe d’éxecution (Main.java) :

  • 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 :

    Personne.java :

     aplicationContext.xml :

    Classe d’éxecution(Main.java) :

     

     

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.

Maven, c’est quoi?

Maven, c’est quoi?

Ce tuto fournit des concepts de bases et avancés de la technologie apache maven3. Notre tutoriel maven est développé pour les débutants et les professionnels.

Maven est un outil de gestion de projet puissant qui est basé sur POM (modèle d’objet du projet ) . Il est utilisé pour des projets build, la dépendance et la documentation .

Il simplifie le processus de construction comme ANT. Mais il est trop avancé que ANT .

Il y a beaucoup de problèmes auxquels nous sommes confrontés lors de l’élaboration du projet. Ils sont décrits ci-dessous:

  • Ajout d’ ensemble de Jars dans chaque projet : dans le cas des frameworks struts, Spring, Hibernate, il faut ajouter un ensemble de fichiers JAR dans chaque projet ainsi l’inclusion de toutes les dépendances de ces fichiers JAR.
  • Création de la structure de projet : Nous devons créer la bonne structure du projet sinon il ne sera pas exécuté.
  • Construction et déploiement du projet : Nous devons avoir à construire et à déployer le projet afin qu’il puisse travailler.

Maven simplifie tous les problèmes mentionnés ci-dessus, et vous aidez également à faire les points ci-dessous :

  • Construire les projets facilement.
  • Il fournit des processus de construction uniforme(un projet maven peut être partagé par tous les autres projets maven).
  • Il fournit des informations sur les projets (documents log, liste de dépendances, rapports de tests unitaires, etc… ).
  • la migration est facile pour les nouvelles versions de Maven.

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.

Qu’est-ce que le framework spring

Qu’est-ce que le framework spring
Spring
est un framework très riche permettant de structurer, d’améliorer et de simplifier l’écriture d’application Java EE.
Spring est un framework libre, un conteneur dit « léger », c’est à dire une infrastructure similaire à un serveur d’application Java EE.

Architecture du framework Spring
Spring_Module

Avantages :
– Les applications Spring sont faiblement couplées grâce à l’injection de dépendance.
– Spring fournit des modèles pour JDBC, Hibernate, JPA, etc. Donc, il n’y a pas besoin d’écrire trop de code.
– Le test des applications est devenu plus facile en utilisant L’injection de dépendance.
– Spring est léger en raison de sa mise en œuvre POJO.
– Spring propose une très bonne intégration avec des frameworks open source(Struts, Jsf, Hibernate, etc…).

Inconvénients :
– les livrables peuvent avoir une taille importante à cause de nombreuses librairies requises par Spring et ses dépendances.

créer une application Spring

Spring est un framework très riche permettant de structurer, d’améliorer et de simplifier l’écriture d’application JEE. Spring est considéré comme un conteneur dit « léger ».

Pour créer une application Spring, nous devons suivre les étapes suivantes : Créer un projet Java, Ajouter les bibliothèques nécessaires (jar files) , Créer une classe java, créer le ficher “applicationContext.xml” et enfin une classe pour exécuter notre application.

– Créer un projet Java :
Afin de pouvoir créer un projet java en utilisant l’ide eclipse : File => New => Java Project
Creation_Projet_Java

– Création de la lasse (Cours.java) :

– Ajouter les bibliothèques nécessaires (jar files) :

Ajouter_Lib

– Création du fichier “applicationContext.xml”

– Création de la classe d’exécution(Main.java) :

– Résultat après l’exécution de la classe Main.java :
Resultat

 

Ci-après une video :

 

Les modules du framework Spring

Les modules du framework Spring :

Le framework Spring fournit environ 20 modules qui peuvent être utilisés sur la base d’une application.
Dans ce tuto nous allons voir les principaux modules :
Spring_Module

Spring Core : le noyau, qui contient à la fois un ensemble de classes utilisées par toutes les briques du framework et le conteneur léger.

Spring AOP : le module de programmation orientée aspect, qui s’intègre fortement avec AspectJ, un framework de POA à part entière.

Spring DAO : qui constitue le socle de l’accès aux dépôts de données, avec notamment une implémentation pour JDBC. D’autres modules fournissent des abstractions pour l’accès aux données (solutions de mapping objet-relationnel, LDAP) qui suivent les mêmes principes que le support JDBC. La solution de gestion des transactions de Spring fait aussi partie de ce module.

Spring ORM : qui propose une intégration avec des outils populaires de mapping objet-relationnel, tels que Hibernate, JPA, EclipseLink ou iBatis.

Spring WEB : le module comprenant le support de Spring pour les applications Web. Il contient notamment Spring Web MVC, la solution de Spring pour les applications Web, et propose une intégration avec de nombreux frameworks Web et des technologies de vue.

Spring Context : Ce module supporte l’internationalisation (I18N), EJB, JMS, Basic Remoting.