Tutoriel Spring N°4.1 : Accès données avec Spring JDBC

////Tutoriel Spring N°4.1 : Accès données avec Spring JDBC

Avec Objis, spécialiste formation Spring
, maîtrisez l’utilisation de Spring JDBC pour créer rapidement votre couche d’accès aux données JDBC (DAO). Utilisez les classes JdbcTemplate et JdbcDaoSupport fournies par Spring. Comparez la configuration de l’injection de dépendances avec XML et avec les annotations @Repository. Mettez en pratique les deux concepts clés de framework Spring : injection de dépendances et la programmation orientée aspects.

Objectifs

 1 : Maîtriser la valeur ajoutée de Spring pour l’accès aux données. En particulier :

— Diminution de la taille du code, grâce à classes fournies par Spring.

— Gestion des exceptions réalisée par Spring pour vous.

 2 : Mettre en œuvre de bonnes pratiques Spring JDBC. Par exemple :

— Configurer la source de données (DataSource) JDBC comme un bean Spring et l’injecter à l’exécution.

— Utiliser le bean PropertyPlacerConfigurer afin de mettre les informations de connexion dans un fichier de propriétés

 3 : Injecter les classes Templates proposés par SPRING

— JdbcTemplate et variantes (SimpleJdbcTemplate, NamedParamJdbcTemplate)

 4 : Créer vos DAO en étendant la Classe JdbcDaoSupport de SPRING

 5 : Annoter vos classes DAO via @Repository

Programme

 Partie 1 : cours et analyse

 Partie 2 : création et Alimentation base de données

 Partie 3 : projet eclipse ‘demospringdatabase’

 Partie 4 : beans d’accès aux données

 Partie 5 : domaine Métier

 Partie 6 : Mise en oeuvre ‘JDBC pur’ dans Spring

 Partie 7 : Mise en oeuvre JdbcTemplate

 Partie 8 : Mise en oeuvre @Repository

Durée

2h.

Partie 1 : Contexte et atouts

Par rapport à une approche ‘JDBC pur’ d’accès à une base de données en Java, Spring apporte 2 valeurs ajoutées :

— 1) Une taille du code d’accès au données plus réduite (pas besoin de gérer les exceptions…! Spring le faire pour vous.)

— 2) En cas d’incident, Spring fournit une gamme d’exception spécifiques (Ex : BadGrammaRException au lieu de SQLException). Il intercepte la SQLException et nous renvoit une excption plus spécifique.

Questions

En utilisant l’API (javadoc) de Spring ainsi que la documentation de référence , citez les packages Spring impliqués dans l’abstraction Spring JDBC

 Qu’est ce que JdbcTemplate

tutoriel-jdbc-template

 Expliquez.

Partie 2 : Création et Alimentation base de données

Installation Wamp5

 Téléchargez et installez WAMP , serveur Apache2/PHP5/MYSQL5 sous Windows

Données de test

 Importez dans la base le fichierformation.sql. Pour cela sélectionnez l’onglet ‘importer’ de WAMP …

Le script crée une table (employe) et y insère 3 enregistrements.Après Importation des données, vous obtenez l’écran suivant.

tutoriel_spring_formation_objis_integration_spring_jdbc_9bis.png

L’étape de création de la base de données et de création de données est terminée. Prochaine étape : création d’un projet eclipse pour notre développement.

Partie 3 : projet eclipse ‘demospringdatabase’

Création du projet Spring

Avec SpringSource Tool Suite (STS) créez un projet Spring nommé ‘demospringdatabase’ . :

 File/new Project/

 Spring/Spring project

 Nom : demodatabase. Puis Finish

tutoriel_spring_formation_objis_integration_spring_jdbc_10.png

INFO : pour les utilisateurs de MAVEN , créer un projet maven de type ‘quickstart

Installation des librairies Spring

INFO : pour les utilisateurs de MAVEN , ajoutez la dépendance suivante à votre pom.xml



org.springframework
spring-jdbc
4.3.11.RELEASE

La suite suppose que vous n’utilisez pas MAVEN.

INFO 2 : pour les non utilisateurs de MAven, suivez la procédure suivante :

 Créez un répertoire ‘lib’ à la racine du projet (Click droit sur le projet / New / Folder). Ce répertoire servira à mettre toutes librairies necessaires.

tutoriel_spring_formation_objis_integration_spring_jdbc_11.png

tutoriel_spring_formation_objis_integration_spring_jdbc_12.png

 Bouton Finish.

Installation librairies Spring 4.

librairies

Installation librairie driver JDBC

 Ajoutez le driver de la base de données mysql-connector-5.jar. Pour l’avoir, téléchargez et dézippez le fichier mysql-connector-java-5.0.5.zip . Le jar se trouve à la racine du dossier.

Installation libairies Pool de connection

Ajoutez les librairies du pool de connexion DBCP .

Pour Spring 4.x, téléchargez commons-dbcp et commons-pool et récupérez les dernières versions des jars commons-dbcp.jar et commons-pool.jar

Configuration Log4j

 Ajouter la librairie log4j.jar présent dans SPRING_HOMEliblog4j.

— dans le répertoire ‘src’ du projet, ajoutez l’exemple de fichier log4j.xml fournit et

 Ajoutez toutes les librairies du répertoire lib dans le ‘build path’ d’Eclipse : Menu project/properties/Librairies/Add jars.

log4j

Fichier de déclaration des beans

 En utilisant l’assistant de création de bean Spring, créez à la racine ‘src’ du projet ‘demospringdatabase’, un fichier spring-data.xml qui sera dédié à la définition de beans relatifs à la base de données. En cas de difficultés de création du fichier, voir le Tutoriel ‘Injection de dépendences

tutoriel_spring_formation_objis_injection_dependences_13.png

Partie 4 : beans d’accès aux données

Configuration propriétés de la base de données

 Créez le package com.objis.spring.demodatabase

 Créez dans le package com.objis.spring.demodatabase un fichier db.properties contenant des informations de connexion en base de données :

— url de connexion

— login

— password

— Driver

tutoriel_spring_formation_objis_integration_spring_jdbc_17.png

 Déclarez dans spring-data.xml un bean de type PropertyPlaceholderConfigurer, qui assure la récupération dynamique des informations présentes dans le fichier de propriété db.properties

tutoriel_spring_formation_objis_integration_spring_jdbc_18.png

Déclaration beans ‘datasource1’ et ‘datasource2’

 Dans le fichier spring-data.xml, déclarez 2 beans ‘datasource1’ et ‘datasource2’ correspondant à 2 types de configuration de la base de données

— ‘datasource1’ : configuration via la classe org.springframework.jdbc.datasource.DriverManagerDataSource, avec information d’accès à la base (URL, Driver; login, pwd) écrites ‘en dur’ dans le fichier XML

— ‘datasource2’ : configuration via classe org.apache.commons.dbcp.BasicDataSource, (de Apache DBCP DataBase Connexion Pool) avec informations d’accès à la base récupérées d’un fichier de propriété : db.properties du package com.objis.spring.demodatabase

tutoriel_spring_formation_objis_integration_spring_jdbc_20.png

 Quelle est la ‘meilleure pratique’ entre ces 2 dataSources ? Pourquoi ?

Partie 5 : Domaine Métier

Dans cette partie, vous crééez le Bean ‘Employe’ possédant les attributs correspondants aux champs de la base de données :

— ID

— login

— password

— nom

— prenom

— email

— rôle

Enregistrement d’un employé en Base de données

 Dans Eclipse, créez le package ‘domaine’

 Dans le package domaine, et en utilisant assistant Eclipse (Cliquez droit sur le code + Source/Generate…) créez pour le bean Employe ainsi que :

— un constructeur sans paramètre : Employe()

— un constructeur avec les 7 paramètres : Employe( int,String,String,String,String,String)

— Getters/Setters pour chaque propriété de la classe Employe

tutoriel_spring_formation_objis_integration_spring_jdbc_19.png

Partie 6 : Mise en oeuvre JDBC pure dans Spring

Dans cette partie vous analysez l’utilisation de Spring avec JDBC pure.

 Ajoutez la librairie JUnit dans le répertoire ‘lib’ puis dans le ‘build path’ Eclipse.

 importez dans le package com.objis.spring.demodatabase le fichier EmployeDao.java

EmployeDao implémente les méthodes :

— saveEmploye() : Enregistrement d’un employé en base, avec méthode JDBC pure

— getEmployebyId(): récupération d’un objet Employe à partir de son id

Analysez le code suivant du Dao :
injection-datasource-spring-jdbc

 Expliquez.

Ci-dessous méthode saveEmploye().

injection-datasource-spring-jdbc-2

 Analysez le code de ces méthodes.

 Expliquez.

 Ajoutez le bean DAO dans le conteneur

injection-datasource-spring-jdbc-4

 Expliquez la relation entre le DAO et la DataSource

 importez dans le package com.objis.spring.demodatabase.test le fichier TestSpringJDBC.java fournis.

injection-datasource-spring-jdbc-3

Ci-dessous l’arborescence du projet :

tutoriel_spring_formation_objis_integration_spring_jdbc_25.png

 Testez la méthode saveEmploye. Pour cela cliquez droit sur la méthode testSaveEmploye() de TestSpringJDBC puis Run as JUnit Test.

tutoriel_spring_formation_objis_integration_spring_jdbc_26.png

 Analysez les résultats du test : création d’un nouvel enregistrement en base de données.

tutoriel_spring_formation_objis_integration_spring_jdbc_27.png

 Testez la méthode getEmployeById. Pour cela cliquez droit sur la méthode testGetEmployeById() de TestSpringJDBC puis Run as JUnit Test.

 Analysez les résultats du test : création d’un objet employe non Null.

Correction

TELECHARGEZ le PROJET

demospringjdbc-Dao-Version1

Partie 7 : Mise en oeuvre JdbcTemplate

Spring propose la classe JdbcTemplate pour vous simplifier l’accès à une base de données en Java. 2 avantages :

— 1) Moins de code à écrire dans votre DAO. En particulier plus besoin des try/catch. Top non ?

— 2) Meilleure Gamme d’exceptions : au lieu de vous retourner des ‘SQLException’ en cas d’Erreur Spring vous renvoie une exception personnalisée plus précise.

 Ajoutez l’interface suivante qui devra être implémentée par la classe EmployeDao2 (notre nouvelle version de DAO).

injection-Template-spring-jdbc-0

 Déclarez un bean JdbcTemplate dans le fichier de configuration de Spring

tutoriel_spring_formation_objis_integration_spring_jdbc_28.png

 Créer une classe EployeDao2 et déclarez une propriété de type JdbcTemplate

injection-Template-spring-jdbc-1

 Implémentez dans SpringJDBC la saveEmployeJdbcTemplate() : Enregistrement d’un employé en base, avec Template jdbcTemplate, fourni par SPRING

injection-Template-spring-jdbc-2

 Déclarez votre EmployeDao2 dans le conteneur

injection-Template-spring-jdbc-3

 Ecrivez une méthode de test JUnit associée à la méthode saveEmployeJdbcTemplate()

Correction

demospringdaoTemplatejdbc

A VOUS DE JOUER : à partir de la documentation de JdbcTemplate, complétez l’implémentation de l’interface par le Dao. En particulier, codez les méthodes getEmployeByLogin(), getEmployesCount() et getAllEmployes().

Partie 8 : Annotations Spring @Repository

Depuis Spring 2.0, l’utilisation des annotations à l’intérieur du code des beans contribue à une réduction du code XML de configuration de ces beans dans le fichier de définition XML. En particulier, les annotations @Repository (couche persistence), @Controller (couche web) et @Service (couche service) sont spécifique à Spring et héritent de l’annotation @Component de la spécification JEE (JSR 250).

REMARQUE: la translation d’exceptions représente une valeur ajoutée de la configuration des beans par annotations par rapport à la configuration XML.

A partir de la version 2, spring peut détecter des classes annotées, grace à la balise ‘‘. Cela nécessite la déclaration dans le fichier de déclaration des beans du namespace context.

 Annotez le DAO EmployeDao , en utilisant l’annotation @Repository.

tutoriel_spring_formation_objis_integration_spring_jdbc_32.png

Optimisation du fichier spring-data.xml

Nous allons modifier le fichier spring-data.xml de façon à ce que Spring tienne compte des annotations réalisées dans les beans.

 Déclarez le namespace ‘context’.

 Informez SPRING du lieu ou se trouvent vos classes annotées (‘‘).

 Informez SPRING de votre stratégie d’Autowiring par défaut (default-autowire) pour tous les beans déclarés.

Ces actions sont réalisées dans le schéma ci-dessous :

tutoriel_spring_formation_objis_integration_spring_jdbc_31.png

 Commentez la déclaration du DAO EmployeJdbcDaoSupport dans spring-data.xml

tutoriel_spring_formation_objis_integration_spring_jdbc_34.png

Tests DAO

 Testez à nouveau l’accès aux données (méthodes testSaveEmploye et testGetEmployeById)

Le code de le classe de test est le suivant :

tutoriel_spring_formation_objis_integration_spring_jdbc_33.png

Les résultats :

tutoriel_spring_formation_objis_integration_spring_jdbc_35.png

TELECHARGEZ le PROJET ECLIPSE CORRIGE POUR @Repository

Gestion des exceptions

 Mettez en évidence la valeur ajoutée du mécanisme de translation d’exceptions de Spring

Partie 9 : Ajout couche Service

 Ajoutez dans un nouveau package le code d’une classe couche Service qui utilise une propriété de type Interface IEmployeDao.

tutoriel-spring-jdbc-ajout-couche-service5

 Injectez un DAO dans la couche service.

 Mettez en évidence un cas de conflit : Spring ne sait pas quel DAO injecter parmi les 2 DAOs qui implémentent l’interface.

 Proposez 2 stratégies pour gérer ce cas de conflit :

— > Stratégie 1 basée sur l’annotation @Repository (donner en paramètre de Repository un nom qui est le même que la propriété de la couche Service)

— > Stratégie 2 basée sur l’annotation @Qualifier à ajouter dans la couche Service (donner en paramètre un des noms donnés aux DAO via Repository)

demoservicedao

Conclusion

Dans ce tutoriel, vous avez pratiqué la mise en oeuvre de l’intégration de Spring avec une base de données relationnelle.

CORRECTION

XML+Annotations

couche_dao_avec_Spring

Full Annotations

couche_dao_avec_Spring_-_full_Annotations

2018-01-30T08:00:33+01:00

Contactez nous

241 rue DUGUESCLIN, 69003 Lyon

Web : Objis : spécialiste formation Java