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.

Introduction à jQuery

Qu’est ce que jQuery?

jQuery est un framework JavaScript complet. Il comporte ainsi une série de fonctions dites utilitaires. Il n’est pas possible, dans le cadre de ce cours, de les passer toutes en revue. Celles-ci peuvent être consultées dans la documentation de jQuery à l’adresse :http://api.jquery.com/category/utilities/.

Éviter les conflits

pour le développement des applications récentes. Leur cohabitation pose souvent des problèmes car le signe dollar $ est utilisé par chacun d’eux. Pour rappel, jQuery utilise le $ comme alias de “jQuery”.

La méthode jQuery.noConflict() permet d’éviter les conflits possibles avec les autres frameworks. Ainsi l’appel à $ dans le code du script ne sera plus considéré comme du jQuery et sera réservé aux autres librairies. Le nommage initial jQuery sera repris pour le code jQuery.

Pour plus de détails, voir : http://learn.jquery.com/using-jquery-core/avoid-conflicts-other-libraries/

Exemple Soit deux divisions. Le contenu de l’une est géré par jQuery et l’autre par Prototype.

Explications du script.

// Partie jQuery jQuery.noConflict();

La méthode jQuery.noConflict() indique à jQuery de ne plus prendre en compte les variables $.

jQuery(’#jquery’).addClass(’jquery’);

Le signe $ est remplacé par jQuery.

// Partie Prototype $(’prototype’).addClassName(’prototype’);

Instruction gérée par Prototype. Le signe $ n’est plus considéré comme du jQuery grâce à l’instructionjQuery.noConflict().

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 :

 

Testez votre application java avec JUnit 4

Testez votre application java avec JUnit 4!
final-logo

 

JUnit est un framework open source pour le développement et l’exécution de tests unitaires manuelles et automatisables pour Java.

Dans ce tuto, nous allons voir les points suivants :

  • Types de tests unitaires.
  • Annotations qu’il faut utiliser pour JUnit 4.
  • Classe Assert.
  • Un exemple d’utilisation de JUnit 4.

Types de tests unitaires

Nous avons 2 types pour effectuer les tests unitaires JUnit.

  1. Test Manuel : c’est de lancer le test manuellement sans aucun soutien de l’outil, dans ce cas le test ne sera pas fiable et beaucoup de temps sera perdu.
  2. Test automatisé : C’est l’exécution des cas de test par le soutien de l’outil, dans ce cas le test est rapide et plus fiable.

Annotations qu’il faut utiliser pour JUnit

Le framework JUnit 4 est basé sur la notion des annotations, alors voyons les annotations qui peuvent être utilisées lors de l’écriture des scénarios de test.

@Test : spécifie que cette méthode est la méthode d’essai.
@Test(timeout=1000) : précise que la méthode ne sera pas acceptée si l’exécution prend plus de 1000 millisecondes (1 seconde).
@BeforeClass : précise que la méthode sera invoquée qu’une seule fois avant de commencer tous les test.
– @Before :  précise que la méthode sera appelée avant chaque test.
@AfterClass : précise que la méthode sera invoquée qu’une seule fois après avoir terminé tous les tests.
@After : précise que la méthode sera appelée après chaque essai.

Classe Assert

Cette classe fournit un ensemble de méthodes d’assertion utiles pour l’écriture de tests, nous allons doc voir certaines méthodes :
void assertEquals(boolean expected, boolean actual) : Vérifiez que deux primitives/objets sont égaux.
 void assertTrue(boolean expected, boolean actual) : Vérifiez qu’une condition est vraie.
 void assertFalse(boolean condition) : Vérifiez qu’une condition est fausse.
 void assertNotNull(Object object) :  Vérifiez que l’objet n’est pas null.
– void assertNull(Object object) : Vérifiez que l’objet est null.
 void assertSame(boolean condition) : Cette méthode vérifie si deux références d’objets pointent sur le même objet.
 void assertNotSame(boolean condition) : Cette méthode vérifie si deux références d’objets ne pointent pas sur le même objet.

Un exemple d’utilisation de JUnit 4

Afin de pouvoir travailler avec JUnit, nous avons besoin d’utiliser deux fichier jar junit4.jar & hamcrest-core.jar

Nous allons créer la classe “Cours” qui contient la méthode “NbCours” pour vérifier le nombre de cours.

Et après, nous allons également créer la classe “Test” pour lancer notre premier Test JUnit :

Après avoir lancer le test sur JUnit Test le résultat est le suivant :
test1

Donc comme vous voyer, le test est bien passé. Nous allons refaire le même test en modifiant dans la méthode assertEquals”mettre 4 au lieu de 5 donc les 2 valeurs ne sont pas égaux 4<>5″.

Le résultat est :
test2

 

Qu’est-ce que le framework Hibernate

Qu’est-ce que le framework Hibernate ?

Hibernate est un Framework open source, léger & ORM, ce dernier à été lancé en 2001 par Gavin King.

Hibernate est un Framework de persistance utilisé pour gérer la persistance des objets java dans une base de données, il peut être utilisé dans un développement web ou bien un développement client lourd.
Hibernate peut utiliser sql comme il peut utiliser son propre langage de requête HQL(Hibernate Query Language).

ORM(Object relational mapping) : c’est une méthode de programmation pour mapper les objets.

HQL(Hibernate Query Language) : est la version orienté objet du langage sql (on utilise le nom de la classe au lieu du nom de la table).

Architecture du framework Hibernate 

Hibernate architecture

Les avantages et les inconvénients du framework Hibernate :

Avantages :

  • Base de données indépendante : on n’a pas besoin d’écrire un code spécifique pour la base de données (si on ne change la bd, on ne sera pas obligé à modifier dans le code l’application “requêtes sql” ).
  • On peut mettre à jour la base de données sans écrire du code sql ou hql.
  • Le framework Hibernate est opensource sous licence LGPL.

Inconvénients :

  • Il est un peu difficile de faire des requêtes complexe avec HQL.

Qu’est-ce que le framework spring

Qu’est-ce que le framework spring ? Spring est maintenant plus qu’un conteneur léger, utilisé pour le développement d’applications d’entreprise. Il constitue le socle de nombreux projets. Il peut être considéré comme un framework de frameworks car il fournit un soutien aux différents framework tels que Struts, Hibernate, EJB, JSF etc. Le framework, en sens large, peut être définie comme une structure où l’on trouve la solution des différents problèmes techniques.

Il y a plusieurs avantages du framework Spring :

– Templates prédéfinis :
Le framework Spring fournit des templates pour JDBC, Hibernate, JPA, etc… Donc, il n’y a pas besoin d’écrire trop de code. Il cache les étapes de base de ces technologies.

– Couplage faible :
Les applications Spring sont faiblement couplés en raison de l’injection de dépendance.

– Facile à tester :
L’injection de dépendance rend plus facile à tester l’application

– léger :
Le framework Spring est léger en raison de sa mise en œuvre POJO. Le framework Spring ne force pas le programmeur d’hériter une classe ou mettre en œuvre n’importe quelle interface.

Les inconvénients du framework Spring :

Parfois les livrables aient une taille importante du fait des nombreuses librairies requises par Spring et ses dépendances.