Module : Java Avancé – L3
Chapitre : JDBC
Accès aux Bases de Données en Java
Dr Chérif Ndiaye
ISEP Diamniadio
20 février 2026
Table des matières
1 Introduction Générale à JDBC 3
1.1 Contexte et Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Définition de JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Objectifs Pédagogiques du Chapitre . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Problématique de l’Accès aux Données . . . . . . . . . . . . . . . . . . . . 4
1.5 Architecture Générale de Communication . . . . . . . . . . . . . . . . . . . 4
1.6 Le Driver JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7 Types de Drivers JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7.1 Type 1 : Bridge JDBC-ODBC . . . . . . . . . . . . . . . . . . . . . 4
1.7.2 Type 2 : Driver natif . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7.3 Type 3 : Driver réseau . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.7.4 Type 4 : Driver 100% Java . . . . . . . . . . . . . . . . . . . . . . . 5
1.8 Rôle Central de JDBC dans l’Écosystème Java . . . . . . . . . . . . . . . . 5
1.9 Limites de JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.10 Conclusion du Chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Architecture de JDBC 6
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Vue d’ensemble de l’architecture . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Composants Principaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.1 1. Driver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.2 2. DriverManager . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.3 3. Connection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.4 4. Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.5 5. ResultSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 Cycle de Vie d’une Requête JDBC . . . . . . . . . . . . . . . . . . . . . . 7
2.5 Exemple Complet du Cycle . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6 Responsabilités de Chaque Composant . . . . . . . . . . . . . . . . . . . . 8
2.6.1 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6.2 API JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6.3 Driver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.4 Base de Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.7 Connexion JDBC : Structure de l’URL . . . . . . . . . . . . . . . . . . . . 9
2.8 Gestion des Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.9 Problèmes Courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.10 Vers une Architecture Professionnelle . . . . . . . . . . . . . . . . . . . . . 10
2.11 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1
3 Connexion à une base MySQL 11
3.1 Dépendance Maven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Exemple de connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4 Requêtes SQL avec JDBC 12
4.1 Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2 PreparedStatement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5 Manipulation du ResultSet 13
6 Opérations CRUD 14
6.1 Insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.2 Mise à jour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.3 Suppression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
7 Gestion des Exceptions 15
7.1 Try-with-resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8 Transactions 16
8.1 Transaction manuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
9 Pattern DAO 17
9.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
9.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
10 Comparaison JDBC vs ORM 18
11 Conclusion 19
2
Chapitre 1 Introduction Générale à JDBC
1.1 Contexte et Motivation
Dans les systèmes d’information modernes, les applications logicielles manipulent en
permanence des données persistantes. Ces données sont généralement stockées dans des
bases de données relationnelles telles que MySQL, PostgreSQL ou Oracle.
Le langage Java étant largement utilisé pour le développement d’applications d’entre-
prise, il est nécessaire de disposer d’un mécanisme standardisé permettant :
— La connexion à une base de données relationnelle
— L’exécution de requêtes SQL
— La récupération et la manipulation des résultats
— La gestion des transactions
— La gestion des erreurs liées aux opérations SQL
C’est dans ce contexte qu’intervient JDBC (Java Database Connectivity).
1.2 Définition de JDBC
JDBC est une API (Application Programming Interface) standard fournie par Java
permettant aux applications Java d’interagir avec des bases de données relationnelles.
Elle fait partie du package :
1 java . sql
et propose un ensemble d’interfaces et de classes permettant d’effectuer des opérations
de type CRUD (Create, Read, Update, Delete).
1.3 Objectifs Pédagogiques du Chapitre
À l’issue de ce chapitre, l’étudiant doit être capable de :
— Comprendre le rôle de JDBC dans l’architecture d’une application Java
— Expliquer le fonctionnement de la communication Java Base de données
— Identifier les composants principaux de l’API JDBC
— Comprendre la notion de driver JDBC
— Situer JDBC par rapport aux frameworks ORM modernes
3
1.4 Problématique de l’Accès aux Données
Une application Java ne peut pas communiquer directement avec une base de données
relationnelle. En effet :
— Les bases de données utilisent le langage SQL
— Java est un langage orienté objet
— Il existe un décalage entre modèle objet et modèle relationnel
Ce problème est connu sous le nom de :
Impedance Mismatch Objet-Relationnel
JDBC agit comme un intermédiaire entre ces deux mondes.
1.5 Architecture Générale de Communication
Le processus de communication suit les étapes suivantes :
1. L’application Java envoie une requête SQL
2. Le driver JDBC traduit cette requête
3. La base de données exécute la requête
4. Les résultats sont retournés à l’application Java
1.6 Le Driver JDBC
Le driver JDBC est un composant logiciel spécifique à un SGBD (Système de Gestion
de Base de Données).
Chaque base de données fournit son propre driver :
— MySQL Connector/J
— PostgreSQL JDBC Driver
— Oracle JDBC Driver
Le driver permet :
— L’établissement de la connexion réseau
— La conversion des requêtes Java vers le protocole du SGBD
— La récupération des résultats
1.7 Types de Drivers JDBC
Historiquement, il existe quatre types de drivers :
1.7.1 Type 1 : Bridge JDBC-ODBC
— Utilise un pont ODBC
— Dépend d’une configuration locale
— Obsolète
1.7.2 Type 2 : Driver natif
— Utilise des bibliothèques natives
— Dépend du système d’exploitation
4
1.7.3 Type 3 : Driver réseau
— Utilise un serveur intermédiaire
1.7.4 Type 4 : Driver 100% Java
— Implémenté entièrement en Java
— Indépendant du système
— Le plus utilisé aujourd’hui
1.8 Rôle Central de JDBC dans l’Écosystème Java
Bien que des frameworks modernes comme :
— Spring Boot
— Hibernate
— JPA
simplifient l’accès aux données, ils reposent tous sur JDBC en interne.
Comprendre JDBC permet :
— De comprendre les erreurs SQL
— De comprendre la gestion des transactions
— D’optimiser les performances
— De mieux utiliser les ORM
1.9 Limites de JDBC
Malgré sa puissance, JDBC présente certaines limites :
— Code verbeux
— Gestion manuelle des ressources
— Manipulation explicite du SQL
— Mapping manuel objet-relationnel
Ces limites ont conduit à l’émergence des ORM.
1.10 Conclusion du Chapitre
JDBC représente la base fondamentale de la persistance en Java. Il constitue un pas-
sage obligatoire avant l’apprentissage de technologies avancées telles que Spring Data
JPA.
La maîtrise de JDBC permet :
— Une meilleure compréhension des architectures backend
— Une meilleure gestion des performances
— Une compréhension fine du lien Java Base de données
5
Chapitre 2 Architecture de JDBC
2.1 Introduction
Après avoir introduit JDBC et son rôle dans l’écosystème Java, il est essentiel de
comprendre son architecture interne.
L’API JDBC repose sur une architecture en couches permettant la séparation des
responsabilités entre :
— L’application Java
— Le pilote JDBC
— Le gestionnaire de pilotes (DriverManager)
— Le système de gestion de base de données (SGBD)
Cette architecture garantit :
— Portabilité
— Indépendance vis-à-vis du SGBD
— Standardisation
2.2 Vue d’ensemble de l’architecture
L’architecture JDBC peut être représentée de manière conceptuelle comme suit :
Application Java
↓
API JDBC ([Link])
↓
DriverManager
↓
Driver JDBC
↓
Base de Données
Chaque couche a un rôle précis que nous allons détailler.
2.3 Composants Principaux
2.3.1 1. Driver
Le driver JDBC est une implémentation spécifique fournie par le SGBD.
Il assure :
— La communication réseau avec la base
6
— La traduction des requêtes SQL
— La conversion des types Java SQL
Exemple de driver MySQL :
1 com . mysql . cj . jdbc . Driver
2.3.2 2. DriverManager
La classe DriverManager joue le rôle d’intermédiaire.
Elle :
— Charge les drivers disponibles
— Sélectionne le driver approprié
— Établit la connexion
Exemple :
1 Connection conn = DriverManager . getConnection (
2 " jdbc : mysql :// localhost :3306/ ecole " ,
3 " root " ,
4 " root "
5 );
2.3.3 3. Connection
L’interface Connection représente une session active avec la base de données.
Elle permet :
— Créer des requêtes (Statement)
— Gérer les transactions
— Fermer la connexion
2.3.4 4. Statement
Interface permettant d’exécuter des requêtes SQL.
Types :
— Statement
— PreparedStatement
— CallableStatement
2.3.5 5. ResultSet
Représente le résultat d’une requête SELECT.
Il agit comme un curseur parcourant les lignes retournées.
2.4 Cycle de Vie d’une Requête JDBC
Le cycle d’exécution complet comprend :
1. Chargement du driver
2. Établissement de la connexion
7
3. Création du Statement
4. Exécution de la requête
5. Traitement du ResultSet
6. Fermeture des ressources
2.5 Exemple Complet du Cycle
1 import java . sql .*;
2
3 public class ExempleJDBC {
4
5 public static void main ( String [] args ) {
6
7 String url = " jdbc : mysql :// localhost :3306/ ecole " ;
8 String user = " root " ;
9 String password = " root " ;
10
11 try ( Connection conn = DriverManager . getConnection ( url ,
user , password ) ;
12 PreparedStatement ps = conn . prepareStatement ( " SELECT ␣ *
␣ FROM ␣ etudiant " ) ;
13 ResultSet rs = ps . executeQuery () ) {
14
15 while ( rs . next () ) {
16 System . out . println ( rs . getString ( " nom " ) ) ;
17 }
18
19 } catch ( SQLException e ) {
20 e . printStackTrace () ;
21 }
22 }
23 }
2.6 Responsabilités de Chaque Composant
2.6.1 Application
— Formule les requêtes SQL
— Traite les données récupérées
2.6.2 API JDBC
— Définit les interfaces standards
— Garantit la portabilité
8
2.6.3 Driver
— Implémente les interfaces
— Traduit les appels Java en protocole BD
2.6.4 Base de Données
— Exécute le SQL
— Retourne les résultats
2.7 Connexion JDBC : Structure de l’URL
Une URL JDBC suit la structure :
jdbc :sous-protocole ://hôte :port/base
Exemple MySQL :
1 jdbc : mysql : // localhost :3306/ ecole
Composants :
— jdbc → protocole
— mysql → sous-protocole
— localhost → serveur
— 3306 → port
— ecole → base
2.8 Gestion des Ressources
Il est essentiel de fermer :
— ResultSet
— Statement
— Connection
Utiliser :
1 try - with - resources
permet une fermeture automatique.
2.9 Problèmes Courants
— Oubli de fermeture de connexion
— Mauvaise gestion des exceptions
— Connexions multiples non contrôlées
— Absence de pool de connexions
9
2.10 Vers une Architecture Professionnelle
Dans une architecture professionnelle :
— Les connexions sont gérées par un pool
— Le code JDBC est encapsulé dans des DAO
— Les transactions sont contrôlées
Cela prépare l’étudiant à comprendre Spring Boot et les frameworks modernes.
2.11 Conclusion
L’architecture JDBC repose sur une séparation claire des responsabilités entre appli-
cation, API, driver et base de données.
Comprendre cette architecture est fondamental pour :
— Optimiser les performances
— Déboguer efficacement
— Concevoir des applications robustes
10
Chapitre 3 Connexion à une base MySQL
3.1 Dépendance Maven
1 < dependency >
2 < groupId > com . mysql </ groupId >
3 < artifactId > mysql - connector - j </ artifactId >
4 < version > 8.3.0 </ version >
5 </ dependency >
3.2 Exemple de connexion
1 import java . sql . Connection ;
2 import java . sql . DriverManager ;
3
4 public class TestConnexion {
5 public static void main ( String [] args ) throws Exception {
6
7 String url = " jdbc : mysql :// localhost :3306/ ecole " ;
8 String user = " root " ;
9 String password = " root " ;
10
11 Connection conn = DriverManager . getConnection ( url , user ,
password ) ;
12
13 System . out . println ( " Connexion ␣ r u s s i e ␣ ! " ) ;
14 conn . close () ;
15 }
16 }
11
Chapitre 4 Requêtes SQL avec JDBC
4.1 Statement
1 Statement stmt = conn . createStatement () ;
2 ResultSet rs = stmt . executeQuery ( " SELECT ␣ * ␣ FROM ␣ etudiant " ) ;
Inconvénient : Vulnérable aux injections SQL.
4.2 PreparedStatement
1 String sql = " SELECT ␣ * ␣ FROM ␣ etudiant ␣ WHERE ␣ id ␣ = ␣ ? " ;
2 PreparedStatement ps = conn . prepareStatement ( sql ) ;
3 ps . setInt (1 , 1) ;
4
5 ResultSet rs = ps . executeQuery () ;
Avantages :
— Sécurité accrue
— Meilleure performance
— Pré-compilation
12
Chapitre 5 Manipulation du ResultSet
1 while ( rs . next () ) {
2 int id = rs . getInt ( " id " ) ;
3 String nom = rs . getString ( " nom " ) ;
4 double moyenne = rs . getDouble ( " moyenne " ) ;
5
6 System . out . println ( nom + " ␣ -␣ " + moyenne ) ;
7 }
13
Chapitre 6 Opérations CRUD
6.1 Insertion
1 String sql = " INSERT ␣ INTO ␣ etudiant ( nom , ␣ moyenne ) ␣ VALUES ␣ (? , ␣ ?) " ;
2 PreparedStatement ps = conn . prepareStatement ( sql ) ;
3 ps . setString (1 , " Ali " ) ;
4 ps . setDouble (2 , 14.5) ;
5
6 ps . executeUpdate () ;
6.2 Mise à jour
1 String sql = " UPDATE ␣ etudiant ␣ SET ␣ moyenne ␣ = ␣ ? ␣ WHERE ␣ id ␣ = ␣ ? " ;
2 PreparedStatement ps = conn . prepareStatement ( sql ) ;
3 ps . setDouble (1 , 16.0) ;
4 ps . setInt (2 , 1) ;
5
6 ps . executeUpdate () ;
6.3 Suppression
1 String sql = " DELETE ␣ FROM ␣ etudiant ␣ WHERE ␣ id ␣ = ␣ ? " ;
2 PreparedStatement ps = conn . prepareStatement ( sql ) ;
3 ps . setInt (1 , 1) ;
4
5 ps . executeUpdate () ;
14
Chapitre 7 Gestion des Exceptions
7.1 Try-with-resources
1 try ( Connection conn = DriverManager . getConnection ( url , user ,
password ) ;
2 PreparedStatement ps = conn . prepareStatement ( sql ) ) {
3
4 // traitement
5
6 } catch ( SQLException e ) {
7 e . printStackTrace () ;
8 }
15
Chapitre 8 Transactions
8.1 Transaction manuelle
1 conn . setAutoCommit ( false ) ;
2
3 try {
4 // operations
5 conn . commit () ;
6 } catch ( SQLException e ) {
7 conn . rollback () ;
8 }
16
Chapitre 9 Pattern DAO
9.1 Principe
Séparer la logique métier de l’accès aux données.
9.2 Exemple
1 public class EtudiantDAO {
2
3 private Connection conn ;
4
5 public EtudiantDAO ( Connection conn ) {
6 this . conn = conn ;
7 }
8
9 public List < Etudiant > findAll () throws SQLException {
10 List < Etudiant > liste = new ArrayList < >() ;
11 String sql = " SELECT ␣ * ␣ FROM ␣ etudiant " ;
12
13 try ( PreparedStatement ps = conn . prepareStatement ( sql ) ;
14 ResultSet rs = ps . executeQuery () ) {
15
16 while ( rs . next () ) {
17 Etudiant e = new Etudiant (
18 rs . getInt ( " id " ) ,
19 rs . getString ( " nom " ) ,
20 rs . getDouble ( " moyenne " )
21 );
22 liste . add ( e ) ;
23 }
24 }
25 return liste ;
26 }
27 }
17
Chapitre 10 Comparaison JDBC vs ORM
JDBC ORM
SQL manuel Mapping automatique
Bas niveau Abstraction élevée
Verbeux Productif
18
Chapitre 11 Conclusion
JDBC constitue la base fondamentale de l’accès aux données en Java. La compréhen-
sion de cette API est indispensable avant l’étude de frameworks modernes comme Spring
Boot et JPA.
19