Introduction Spring

Un framework est un cadre de développement qui contient des bonnes pratiques et qui permet d’éviter de recoder des classes utilitaires pour le but de se focaliser sur le metier.

Spring est un framework open source pour construire et définir l’infrastructure d’une application Java, dont il facilite le développement et les tests. Spring à la base est un projet communautaire sponsorisé par  « VMWare » .

Le framework Spring fournit un cadre de travail pour simplifier les aspects techniques des projets. Les sous-projets de spring traitent de problématiques techniques plus spécifiques comme ( Réaliser un batch, un web service, sécuriser son application…)

Spring et le Marché de l’Emploi

La plupart des offres d’emploi , en général cherchent des développeurs dans les technologies Spring. Plusieurs applications web sont en cours d’être immigré vers des nouvelles technologies tels que Spring ce qui valorise ce Framework et le rendre parmis les plus répandus dans le monde du JAVA.

Contenu du Module Spring

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

Chaque module presente un « sous-projet » de Spring.

Figure 1: Spring

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.

Spring MVC : C’est un Framework concurrent de Struts. Il permet de manière flexible de créer des interfaces web évoluées, tout en bénéficiant des fonctionnalités de Spring Core (ou Framework Spring).

Présentation et Installation des Outils

La création des applications avec le framework Spring nécessite une préparation d’environnement de développement. Pour cela, nous allons installer les outils suivants :

  • JDK 8 : Le framework spring necessite l’instalation du JDK.
  • STS ( Eclipes IDE ) : Comme environnement de développement intégré.
  • Maven : Comme outil de gestion et d’automatisation de production des projets logiciels.
  • My SQL (WAMP ) : Comme système de gestion de bases de données relationnelles.

Spring IOC

Le coeur de Spring est composé de Spring Core : un conteneur qui implémente le motif de conception IoC (Inversion of Control). Ce conteneur prend en charge la création, la gestion du cycle de vie et les dépendances des objets qu’il gère. La définition de ces objets est faite dans la déclaration du contexte de Spring dans un fichier de configuration XML ou partiellement réalisée en utilisant des annotations. Pour mettre en oeuvre certaines fonctionnalités, Spring a recourt à la programmation orientée aspect (AOP : Aspect Oriented Programming).

  • IOC

L’IOC (Inversion de Control) est un patron d’architecture commun à tous les frameworks. Il fonctionne selon le principe que l’exécution de l’application n’est plus sous le contrôle direct de l’application elle-même mais du Framework sous-jacent.

Couplage fort et couplage faible 

Le couplage est une métrique indiquant le niveau d’interaction entre deux ou plusieurs composants logiciels (Class, Module…)

  • On parle de couplage fort si les composants échangent beaucoup d’information.
  • On parle de couplage faible si les composants échangent peu d’informations.

Exemple de couplage fort :

  • La classe A ne peut fonctionner que a la présence de la classe B !!

  • Dans l’exemple précédent, Ies classes Metierlmpl et Daolmpl sont liées par un couplage fort. De meme pour les classe Presentation et Metierimpl.
  • Ce couplage fort n’a pas empeché de résoudre le problème au niveau fonctionnel.
  • Mais cette conception nous n’a pas permis de céér une application férmée a la modificatian et ouverte a l’extension.
  • En effet la création d’une nouvelle version de la méthode getValue() de la classe Daolmpl, va nous obliger d’éditer le code source de l’application aussi bien au niveau de Daolmpl et aussi MetierImpl. De ce fait nous avons violé le principe « une application doit etre fermé a la modification et ouverte a l’extension» Nous allons voir que nous pourrons faire mieux en utilisant le couplage faible.

Exemple de couplage faible :

  • Pour Utiliser le couplage faible nous devons utiliser les interfaces…
  • Avec le couplage faible, nous pourrons créér des applications fermées a la modification et ouvertes a l’extension.
  • Injection de Dépendance

L’Injection de Dépendance est la forme principale de l’IoC. Elle implémente le principe de l’IoC.

L’Injection de Dépendance est une méthode pour instancier des objets et créer les dépendances nécessaires entre elles, sans avoir besoin de coder cela nous-même. Ceci permet de réduire le code relatif aux dépendances. Ce qui permet une lisibilité du code, et permet de gagner en temps de développement.

  • AOP 

L’AOP est utilisée par Spring pour fournir des fonctionnalités transverses (par exemple la gestion des transactions) ou spécifiques (par exemple l’injection de dépendances dans un bean non géré par Spring) de manière déclarative dans la configuration XML ou grâce à des annotations.

  • Bean

JavaBeans est une technologie de composants logiciels écrits en langage Java gérer par Spring.

Lors de la définition d’un bean, vous avez la possibilité de définir la durée de vie de bean. Par exemple, pour forcer Spring à produire une nouvelle instance de bean à chaque fois que vous en avez besoin, vous devez déclarer l’attribut scope du bean comme prototype.

  • Scope 

Il existe plusieurs types de Bean (scope):

  • Singleton: Une seule instance du Bean crée pour chaque Conteneur IoC Spring, et référencée à chaque invocation), scope par défaut.
  • Prototype: Nouvelle instance créée à chaque appel du Bean
  • Request: (Contexte Web uniquement) Nouvelle instance crée pour chaque requête HTTP.
  • Session: une instance du bean par session HTTP.
  • Global-session : une instance du bean par session globale (valable pour les portlets: ensemble d’applications déployées sur un même conteneur web).
  • Bean : déclaration et attributs

On définit un Bean dans un fichier XML, avec une configuration Java ou par annotation pour que Spring puisse le gérer :

  • Class : nom de la classe java.
  • Id : identifiant unique de bean.
  • Configuration : (scope, init-method, etc..)
  • Property : arguments à passer aux setters de bean au moment de la création.
  • Bean : Injéction de dépendances :

Spring peut se baser sur trois façons différentes pour configurer l’injection de dépendances et la création des beans (instances) :

  1. Déclaration des Beans
  2. XML 

Dans un fichier XML de configuration des beans :

Et dans le code java nous allons créer une classe java TeamMember :

JAVA

Il est également possible de déclarer un Bean directement grâce à une méthode.

Avec l’annotation @Bean sur une méthode, Spring va exécuter la méthode et enregistrer la valeur du return en tant que Bean. A noter qu’il faut l’annotation @Configuration sur la classe qui contient les @Bean, afin d’indiquer à Spring que, lors du scan, il y a des Beans dans cette classe.

Annotation

Chaque bean est annoté @Component

Instanciation du conteneur Spring

Le conteneur Spring gère les beans, il existe deux façons pour instancier le conteneur spring :


Application Web

Application Web - Configuration dans le fichier web.xml
 Application Web – Configuration dans le fichier web.xml

Application Java

Injéction des beans

  • Injéction des beans en se basant sur XML
  • Methode « classique » qui consiste a la création d’un fichier de configuration applicationContext.xml dans laquelle nous allons céer et injecter les beans.
    Exemple : Création de trois beans (dev,sm,po) et les injecter dans une quatirième bean (ScrumTeam).

Nom par défaut : applicationContext.xml

  • Déclaration du schéma utilisé : balises utilisables
  • Déclaration de bean Spring

Figure 2: Fichier de configuration XML – applicationContext.xml

  1. Déclaration et injéction des beans par mutateur

Figure 3: applicatioContext.xml

Déclaration et injéction des beans par constructeur

  • Chargement du conteneur Spring

Figure 6: Instanciation du conteneur – Application Java – utilisation de l’API Spring

  • Configuration Spring se basant sur les Annotations
  • On commence par l’activation des annotations en ajoutant la balise <context :annotation-config/>

  • Une classe annotée @Component est un bean. C’est une annotation générique.
  • Les beans de la couche Controller : @Controller
  • Les beans de la couche Service : @Service
  • Les beans de la couche DAO/Persistence: @Repository
  • Pour injecter l’injection de bean on utilise : @Autowired
  • Pour modifier le scope du bean on utilise : @Scope

@Controller, @Service et @Repository héritent de la classe @Component


Laisser un commentaire