Java pour le développement
d’application
Accéder à une Base de Données
Patterns DAO & Singleton
Pr. Chiheb Chaieb
[Link]@[Link]
Se connecter aux bases de données)
Utilisation de l’API JDBC (Java DataBase Connectivity)
JDBC est une API du niveau SQL permettant à une application
Java de se connecter à la BD, d’exécuter des instructions SQL et
de retrouver les résultats (s’il y en a).
L’API est un ensemble d’interfaces et de classes conçues pour
Connexion aux BD
effectuer des actions sur tout type de BD (MySQL, ORACLE, SQL
Server, Informix, SYBASE , ODBC, ..)
Utilisation d’un gestionnaire de pilotes JDBC
Un pilote JDBC spécifique à une base de données implémente
l’interface [Link]
Peut dialoguer avec tout pilote conforme à l ’API JDBC et qui
sont disponibles sur [Link]/products/jdbc
10/03/2026 2
Se connecter aux bases de données
Etapes à suivre pou accéder à une BD avec JDBC :
Importer le paquetage [Link] : import [Link].*;
Charger le pilote de la BD (librairie .jar)
Se connecter à la base (Connection)
Définir une requête SQL (Statement ..)
Connexion aux BD
Exécuter la requête SQL (executeQuery, executeUpdate)
Traiter le résultat (si nécessaire)
Fermer la connexion (close() ).
Remarque :
La librairie (généralement .jar) désignant le pilote doit être placée
dans le répertoire : Web‐Content/WEB‐INF/lib du projet .
Pour MySQl , cette librairie est : [Link].jdbc_5.[Link].
10/03/2026 3
Accéder aux bases de données
[Link] : constitués d’interfaces définissant les objets
nécessaires :
à la connexion à une base de données
et à la création et exécution de requêtes SQL
Les interfaces :
Connexion aux BD
Statement
CallableStatement, PreparedStatement
DatabaseMetaData, ResultSetMetaData
ResultSet,
Connection
Driver
[Link]/products/jdbc : drivers BD pour Java
10/03/2026 4
Accéder aux bases de données
Principe de fonctionnement
Chaque base de données utilise un pilote (driver) qui lui est
propre et qui permet de convertir les requêtes JDBC dans le
langage natif du SGBDR.
Connexion aux BD
Ces drivers dits JDBC (un ensemble de classes et
d’interfaces Java) existent pour tous les principaux
constructeurs :
MicroSoft, Oracle, Sybase, Informix, DB2, MYSQL, ...
10/03/2026 5
Accéder aux bases de données
Architecture JDBC
Connexion aux BD
10/03/2026 6
Démarches A Suivre
Ajouter la libraire jdbc à votre projet
Connexion aux BD
10/03/2026 7
Ajouter la libraire jdbc à votre projet
Connexion aux BD
10/03/2026 8
Accéder aux bases de données :
1. Charger le Pilote
Le pilote est obligatoire, il convertit les appels JDBC en
appels natifs. Il est nécessaire de connaître le nom de la
classe du pilote JDBC que l’on veut utiliser :
Pilote ORACLE : [Link]
Pilote JDBC/ODBC : [Link]
Connexion aux BD
Pilote mySQL : [Link], etc..
Le chargement du pilote par l'instruction suivante :
[Link]("Pilote BD") throws ClassNotFoundException
Exemple : Driver d'une BD
MySQL
[Link]("[Link] ") throws
ClassNotFoundException;
[Link](" [Link] ") throws ….
Ses instructions se font au niveau de main().
10/03/2026 9
Accéder aux bases de données :
1. Charger le Pilote
Le chargement du pilote se fait en utilisant la méthode
[Link]( "Pilote BD") throws ClassNotFoundException
Chargement du pilote mysql Exception levée si la classe
Connexion aux BD
pilote n’est pas trouvée
[Link]("[Link] ");
[Link]("[Link]");
Chargement du pilote ODBC
10/03/2026 10
Accéder aux bases de données :
2. Se connecter à la base
Pour se connecter à une base de données il faut fournir
une URL qui indique où se trouve la base :
URL ORACLE : jdbc:oracle:thin:host:port:idbase
URL mySQL : jdbc:mysql:host, dbname
Connexion aux BD
URL ODBC : jdbc:odbc:IDDSN
La connexion à la base se fait en utilisant la méthode
[Link]("URL","user","pass")
throws SQLException, qui retourne un objet de type
Connection. Exception levée si la
connexion à la base est
impossible
10/03/2026 11
Accéder aux bases de données :
2. Se connecter à la base
Exemples :
Connection ma_connexion =
[Link]("jdbc:mysql:// localhost:3306
/isetsoDB", "root ", "");
Connexion aux BD
Connexion à une base
mysql nommée isetso,
avec user et pwd
Connection ma_connexion =
[Link]("jdbc:oracle:thin:@dbhost:1521:ORC
L", "scott", "tiger");
Connexion à une base
oracle avec le schéma
scott/tiger
10/03/2026 12
Accéder aux bases de données :
3. Créer et exécuter une requête SQL
La requête ne peut être créée et exécutée que si le pilote
et la connexion à la base sont valides
Il faut avant tout créer une instruction SQL sur la base
(référence) :
Connexion aux BD
createStatement() throws SQLException
Exception levée si l’instruction
SQL ne peut être créée
Statement mon_statement = ma_connexion.createStatement();
La référence de la connexion à
une base de données
10/03/2026 13
Se connecter aux bases de données :
3. Créer et exécuter une requête (Query)
Il faut enfin exécuter la requête en écrivant
concrètement la requête SQL :
executeQuery(String requete) throws SQLException
Connexion aux BD
Exception levée si la requête
SQL n’est pas correcte
ResultSet mon_resultat = mon_statement.executeQuery("SELECT *
FROM emp");
La requête SQL
La référence de la
requête SQL
Objet récipient de
données : recordSet
10/03/2026 14
Se connecter aux bases de données :
3. Créer et exécuter une requête SQL (Query)
Traiter les données retournées :
L ’objet ResultSet (retourné par l’exécution de executeQuery() )
permet d’accéder aux champs des tuples sélectionnés
seules les données demandées sont transférées en mémoire
par le driver JDBC
Connexion aux BD
il faut donc les lire "manuellement" et les stocker dans des
variables pour un usage ultérieur
Il est parcouru itérativement ligne par ligne par la méthode
next() : retourne false si le dernier tuple est lu, true sinon
10/03/2026 15
Se connecter aux bases de données :
3. Créer et exécuter une requête SQL (Query)
chaque appel fait avancer le curseur sur le tuple suivant
initialement, le curseur est positionné avant le premier tuple
exécuter next() au moins une fois pour avoir le premier
while([Link]()) {// Traitement de chaque tuple}
Connexion aux BD
Avec le JDBC 2.0 :
on peut parcourir le ResultSet d’avant en arrière :
next() vs. previous()
en déplacement absolu : aller à la n‐ième ligne
absolute(int row), first(), last(), ...
en déplacement relatif : aller à la n‐ième ligne à partir de la
position courante du curseur, … :
relative(int row), afterLast(), beforeFirst(), ...
10/03/2026 16
Se connecter aux bases de données :
3. Créer et exécuter une requête SQL (Query)
Les colonnes sont référencées par leur numéro ou par leur
nom
L’accès aux valeurs des colonnes se fait par les méthodes de
la forme getTYPE()
Connexion aux BD
Lecture du type de données TYPE dans chaque colonne
du tuple courant
int val = [Link](3) ; // accès à la 3e colonne
String prod = [Link]("PRODUIT") ;
10/03/2026 17
Se connecter aux bases de données :
3. Créer et exécuter une requête SQL (Query)
Pour traiter un objet de type ResultSet il existe de
nombreuses méthodes :
boolean next() : avancer d’une ligne de la table résultante
String getString(String columName) : interroger un champ
Connexion aux BD
String par son nom
String getString(int columnIndex) : interroger un champ String
par son index
int getInt(…) : interroger un champ Integer par son nom ou
index
while (mon_resultat.next()) {
String colonne1 = Accède à la prochaine
mon_resultat.getString(1); ligne s’il y en a
[Link]("Nom:" + colonne1);
} Affiche le résultat en
10/03/2026 ligne 18
Se connecter aux bases de données :
3. Créer et exécuter une requête de MAJ
Les requêtes de MAJ (Insert, Update et Delete) font recours à la
méthode executeUpdate () :
executeUpdate(String requete) throws SQLException
mon_statement.executeUpdate(“Insert into Produit values ….");
Connexion aux BD
La référence de la La requête SQL
requête SQL
Retour de executeUpdate est de type int. et non ResultSet.
Exemple :
mon_statement.executeUpdate("insert into Produit(idProd,libProd,puProd,tvaprod)
values (" + idP + ",' "+ libP+" ', " +puP+" , " +tva+")") ;
Avec
idP = [Link]([Link]()); // colonne int
libp: [Link](); //String
tva = [Link]([Link]()); // colonne double
10/03/2026 19
Se connecter aux bases de données :
4. Fermer les différents espaces
Pour terminer proprement un traitement, il faut
fermer les différents espaces ouverts sinon le
garbage collector s’en occupera mais moins
Connexion aux BD
efficace.
Chaque objet possède une méthode close() :
[Link]();
[Link]();
[Link]();
10/03/2026 20
Accès aux BD : Quiz
Which Statement method executes a SQL a: returns boolean (true if there is
statement and returns the number of rows c: returns a ResultSet (used with se
affected? Qr)
a. [Link](query); d: invalid statment
b. [Link](query);
c. [Link](query);
d. [Link](query);
Connexion aux BD
When using a Statement to execute a query
that returns only one record, it is not necessary to
use the ResultSet's next() method.
a. True
b. False
10/03/2026 21
Accès aux BD : Quiz
The following try-with-resources statement will
properly close the JDBC resources: This illustrates a good practice:
try (Statement stmt = explicitly closing the ResultSet in
[Link](); try-with-resources.
ResultSet rs =
[Link](query)){
Connexion aux BD
//...
[Link]();
} catch (SQLException s) {…
}
a. True
b. False
10/03/2026 22
Connexion aux BD
Le Design Pattern DAO
10/03/2026 23
Généralités
• Un design pattern est un patron de conception :
Solution standard, testée et éprouvée par la
communauté objet, pour répondre à un
problème d'architecture ou de conception de
logiciel.
• Concept issu des travaux du fameux Gang of
Four (GoF : Erich Gamma, Richard Helm, Ralph
Johnson, et John Vlissides).
• publiés dans « Design Patterns: Elements of
Reusable Object‐Oriented Software » édité en
1995 et proposant 23 motifs de conception.
Pourquoi un patron de conception ?
• Quand on accède à une base de données depuis
un langage, il y a de nombreuses façons de faire.
• Où mettre le code SQL ?
• Que faire pour simplifier un futur changement de
base de données cible ?
• Comment obtenir une application la plus
modulaire possible, la plus facilement modifiable
et la plus réutilisable ?
DAO répond à ces questions !
Pourquoi un patron de conception ?
Imaginons que le code SQL est placé dans les objets métier.
Lors d'un changement de SGBD cible, ou si on décide
d'abandonner la solution SGBD pour une solution XML par
exemple, il faudra modifier les objets métiers. Cette solution
n'est donc pas la bonne.
Le patron de conception DAO propose la création :
• une classe singleton pour gérer la connexion à la BD
• des classes métiers représentants les entités du modèle
(classes POJO)
• des classes DAO : une pour chaque classe métier.
Chaque classe DAO contient les méthodes de liaison avec la
base de données, parfois appelées CRUD (pour Create,
Request, Update, Delete).
Pourquoi un patron de conception ?
Les méthodes de suppression et de modification
renvoient un booléen indiquant le succès de l'opération,
la méthode d'insertion renvoie l'identifiant affecté à la
nouvelle ligne de la table
plusieurs méthodes get permettent d'obtenir un objet en
fonction de différents critères de recherche.
Pourquoi un patron de conception ?
La connexion à la base de données
Le patron de conception DAO incite à créer une
classe se chargeant de gérer la connexion à une
Base de Données et qui sera instanciée une
seule fois pour tous les opérations CRUD sur la
BD : classe Singleton
Singleton
• Le patron de conception Singleton est utilisé afin
de s'assurer qu'il n'y ait qu'une seule instance de
de la classe (on implémente ce patron par exemple
pour la classe connexion).
• Les constructeurs sont donc privés, une méthode
de classe publique getInstance permettant
d'accéder à l'unique objet instance de chaque
classe DAO.
• Le premier appel à cette méthode crée l'objet et le
renvoie, les suivants se contentant de renvoyer
l'objet préalablement créé.
Le design pattern : Singleton
L’objectif du pattern singleton est
de garantir qu’une classe ne
possède qu’une seule instance et de
fournir un point d’accès global a
celle-ci.
Connexion aux BD
Le diagramme de classe est comme
suit :
Un attribut statique privé
Un constructeur privé
Une méthode publique et
statique nommé getInstance qui
retourne le type de l’attribut.
10/03/2026 31
Classe Singleton pour la Connexion
import [Link];
import [Link];
import [Link];
public class Connexion {
private static Connection maCx;
private Connexion(){ // constructeur privé pour créer la connexion
try{
[Link]("[Link]");
maCx=[Link]("jdbc:mysql://localhost/DBname","root","");
} catch(SQLException|ClassNotFoundException e){
((Throwable) e).printStackTrace();
[Link]("Problème Connexion sur la BD "+[Link]());
}
}
public static Connection getInstance(){
if(maCx==null)
new Connexion();
return maCx;
}
}
Schéma DAO Final
Classe Singleton :
Connexion <<utilise>>
<<utilise>>
CompteDAO classes techniques ProprietaireDAO
/DAO
<<crée/utilise>> <<crée/utilise>>
Compte classes métiers/ Propriétaire
entités
version mono base de données du patron de conception DAO
Exemple suivi
Produit Fournisseur
idProduit idFournisseur
desigProd nomFournisseur
* 1
Prix
Pour cet exemple, on dispose de classes métiers (entités) Produit et
Fournisseur. Le design Pattern DAO nous guide à concevoir dans notre
application deux classes 'DAO’, associées aux deux classes métiers,
Chaque Classe DAO dispose d'une interface qui exposera les méthodes
de CRUD réalisées Sur la classe Métier,
A titre d'exemple pour la classe DAOProduit nous pouvons avoir les
méthodes suivantes Et qui seront exposée dans l'interface
DAOProduitInterface :
• AjouterProduit ()
• ConsulterProduit()
• ListerProduits()
Les objets DAO
Démarches A Suivre
Ajouter la libraire jdbc à votre projet
Créer les packages : dao, entities, main
Créer une classe singleton sour dao, pour la connexion à la
base de données. Elle sera utilisée par toutes les méthodes de
CRUD définies dans la classe DAO de l'entité.
Créer les classes entités regroupées sous le package entities
Connexion aux BD
Sous dao, créer une interface pour chaque classe DAO
associée à chaque classe entité et qui contiendra toutes les
méthodes de CRUD de base appropriées à réaliser sur l'entité :
création, rechercher , liste , suppression et modification.
Implémenter les interfaces avec les classe DAO
correspondantes
Développer la classe main de test, en prévoyant un test de
connexion sur la base avant tout,
10/03/2026 36
Les Classes Métiers ( Entités)
Dans votre package entités , créer les classes entités
Classe Produit {
‐ idProd : int ;
‐ libProd : string ;
‐ puProd : double ; etc..
+Produit (idP, libP, puP,tvaP) { // constructeur avec param }
Connexion aux BD
+ getter , setters , toString()
Classe Fournisseur {
‐ numf : int ;
‐ nomf : string ;
‐ adrF : string ;
+Fournisseur (numf , nomf, adrF ) { // constructeur avec
param }
+ getter , setters, toString() }
10/03/2026 37
Classes DAO
Dans le package dao, créer l’interface intDaoProduit de la
classe DaoProduit comporant les méthodes suivantes:
+ void ajouter(Produit e) throws ClassNotFoundException; // ajouter
un produit
+ ArrayList<Produit> listerAllProduits () throws
ClassNotFoundException // retourne liste des produits
Connexion aux BD
+ Produit findProduitbyId (int idP) throws ClassNotFoundException
// retourne le produit donné
+ boolean deleteProd (int idP ) throws ClassNotFoundException
// supprimer le produit donné, sinon false }
boolean modiFyProd ( Produit e ) throws ClassNotFoundException
// modifie le produit e
}
idem pour Fournisseur
10/03/2026 38
Classes DaoProduit
Dans le même package dao, créer les classes DAO Suivantes :
Classe DAOProduit implements intDaoProduit{
+ ajouter(Produit e) { // ajouter un produit
,,,,,,,,, }
+ ArrayList<Produit> listerAllProduits () { // retourne liste des
produits
Connexion aux BD
,,,,,,,,,,,,}
+ Produit findProduitbyId (int idP) { retourne le produit donné}
+ boolean deleteProd (int idP ) { supprimer le produit donné,
sinon false }
+ boolean modiFyProd ( Produit e ) { modifie le produit e}
}
idem pour la clas DaoFournisseur
10/03/2026 39
Classe DaoProduit
public class DaoProduit implements intDaoProduit {
// initialiser la connexion vers la BD via la classe statique Connexion:
private Connection maConnection =[Link]();
public DaoProduit() {}
//recherche d’un produit par idProd
public Produit findProduit(int np) throws ClassNotFoundException{
Produit p=new Produit();
try {
Connexion aux BD
Statement statement=[Link]();
String req="Select libprod, puProd from produits where idProd=
"+np;
ResultSet res=[Link](req);
if ([Link]()) // obligatoire pour savoir que le Query is correct
{
[Link](np);
[Link]([Link](1));
[Link]([Link](2));
}
} catch(SQLException e1) { [Link](); }
return p;
}
10/03/2026 40
Classes DaoProduit
public void ajoutProduit(Produit p) { // avec statement
int np=[Link]();
String nom = [Link]();
Double prix= [Link]() ;
Statement statement;
try {
Preparedstatement = [Link]();
Connexion aux BD
String req = "Insert into produits(idprod, libprod, puprod) values
("+np+",’"+nom+" ’, « +prix+ ")";
// exécuter la requette
[Link]("requette insertion : "+ req);
[Link](req);
[Link]();
} catch (SQLException e1) {
// TODO Auto‐generated catch block
[Link]();
}
}
10/03/2026 41
Classes DaoProduit
public void ajoutProduit(Produit p){ // avec prepared statement
int idProd =[Link]();
String libProd = [Link]();
Double puProd= [Link]() ;
try {
// préparer la requête
PreparedStatement statement=ma_connexion.prepareStatement(
" insert into Produit(idProd,libProd ,puProd) values (?,?,?)");
Connexion aux BD
// Complétez binding parameters
[Link](1, idProd)
[Link](2, libProd);
[Link](3, puProd);
// exécuter la requête
[Link]();
} catch (SQLException e1) {
// TODO Auto‐generated catch block
[Link]();
}
}
10/03/2026 42
Classe DaoProduit
public ArrayList<Produit> listeProduits (){
Produit p=new Produit();
ArrayList<Produit> lp=new ArrayList<Produit>();
try {
Statement mon_statement = [Link]();
ResultSet mon_resultat = mon_statement.executeQuery("SELECT
Connexion aux BD
idProd,libProd,puProd,tvaProd FROM Produit ");
while (mon_resultat.next())
{
// reseigner p avec les données lues depuis resultset,
[Link](mon_resultat.getInt(1));
[Link](mon_resultat.getString(2););
…..
// ajouter p dans lp :
[Link](p) }
return lp;
}10/03/2026
// end listeProduits 43
Classe Main
public static void main(String[] args) throws
ClassNotFoundException {
intDaoProduit dao=new DaoProduit(); // instancier
l’interface
//tester connexion
Connection macon =[Link]();
[Link]("connexion: "+macon);
Connexion aux BD
// lister tous les produits
ArrayList l= new ArrayList();
l=[Link]();
[Link]("liste Produits : "+l);
// recherche un produit
Produit p = new Produit();
p=[Link](1);
[Link](" Produit recherché : "+p);
// ajout
p=new Produit (122, "produit test", 125.5);
[Link](p);
10/03/2026 44
}
PreparedStatement Vs Statement
Statement (Basique)
• Exécution directe : Les requêtes SQL sont concaténées sous forme de
chaînes.
• Pas de pré‐compilation : La requête est analysée/compilée à chaque
exécution.
• Vulnérable aux injections SQL
• A utiliser pour des requêtes statiques (sans paramètres variables).
Connexion aux BD
PreparedStatement
Toujours préférer PreparedStatement pour des requêtes dynamiques.
Réutiliser le même PreparedStatement dans des boucles (ex : insertions
batch).
Fermer les ressources dans un bloc try-with-resources :
java
10/03/2026 45
PreparedStatement Vs Statement
Fermer les ressources dans un bloc try-with-resources :
Java
String sql = "INSERT …… VALUES (?, ?)";
try (PreparedStatement pstmt = [Link](sql)) {
[Link](1, "value");
try (ResultSet rs = [Link]()) {
Connexion aux BD
// Traiter les résultats...
}
}
10/03/2026 46
Design Pattern : DAO
END …..
Thanks For your Attention
Connexion aux BD
10/03/2026 47