Les bases de

données et
Rajae El Ouazzani

2017-2018
Les bases de données et Java
(JDBC)
[1, 2]

2017-2018
Plan
 Présentation
 Java Database Connectivity (JDBC)
 Connexion à une base de données
 Les requêtes de sélection
 Les requêtes de mises à jour
 Déconnexion
 SQLException
 Instruction SQL paramétrée
2017-2018
Présentation
 JDBC (Java database connectivity): c’est la relation entre Java et les
bases de données.
 C’est API développée par SUN pour permettre à des applications Java
d'accéder à des bases de données relationnelles quelconques.
 JDBC: un driver (pilot) fournit des outils pour traiter avec les bases de
données.

 Les étapes principales de ce traitement sont:

 Se connecter à une base de données;
 Envoyer une requête SQL;
 Manipuler le résultat.

2017-2018
 Schéma

JDBC Driver Manager

Driver Protocole Natif

API JDBC
Application Appels SQL
?
JAVA Base de Données

Définition
JDBC pour executer, depuis un programme Java, l'ensemble des
Le pilote...
L’API JDBC
ordres SQLpermet
reconnusd'executer des de
par la base instructions SQL.
donnees cible.
établit
JDBC le lien
fait avecdula JDK
partie base (Java
de donnees, en sachant
Development Kit)“lui
: parler".
La
Dans connexion...
JDBC : des classes chargées de gérer un pilote...
Paquage
Elle peut java.sql
s'etablir SIpour
on donne l'adresse depostGresSQL,
la BD a laquelle se connecter...
Des pilotes existent
import java.sql.*; mySQL, Oracle, ACCESS,...

2017-2018
 Interfaces de JDBC
getConnection()

Canal de
communication TCP
vers une BD
createStatement()

gère les requêtes SQL

executeQuery()

gère l’accès aux

tuples d’un résultat

2017-2018
Java Database Connectivity (JDBC)
 JDBC permet à un programme Java d'interagir localement ou à distance
avec une base de données relationnelle.
 Fonctionne selon le principe client-serveur
 Un client : le programme Java
 Un serveur : un SGBD (ex: phpMyAdmin, MySQL, etc)
 Les 3 opérations suivantes doivent être réalisées avant de travailler avec
une BD:
1) Installer un serveur de bases de données exp : phpMyAdmin, MySQL, etc.
2) Charger le driver JDBC.
3) Etablir la connexion avec la base de données pour l’interroger.

2017-2018
Opération 1:
 Télécharger phpMyAdmin du site officiel de phpMyAdmin
"http://www.phpmyadmin.net/home_page/downloads.php"
 Installer phpMyAdmin.
 Vous pouvez utiliser n’importe quel serveur de base de données:
MySQL, oracle, etc.
 Créer une base de données avec les tables et les attributs
correspondants.

2017-2018
Opération 2 :
 Télécharger le driver JDBC nommé : "mysql-connector-java" du site
officiel de MySQL. C’est un dossier compressé. Après
décompression, vous allez trouver le fichier jar correspondant au
driver.

 Ajouter le driver JDBC à votre projet comme suit:

Cliquer avec le bouton droit de la souris sur le nom du projet
dans l’explorateur Eclipse  Propriétés  Java Build Path  onglet
Libraries  cliquer sur le bouton "add external JARs" 
sélectionner le driver JDBC de MySQL.

2017-2018
Opération 3 :
 Ouvrir le projet auquel nous avons ajouté le driver.
 Ajouter des classes au projet et via des instructions Java, le programme
peut:
 charger le pilote (driver).
 ouvrir une connexion.
 envoyer des requêtes SQL.
 récupérer les résultats.
 effectuer des traitement des données ...
 fermer la connexion.

2017-2018
Architecture d'une application JDBC
import java.sql.DriverManager; // gestion des pilotes
import java.sql.Connection; // une connexion à la BD
import java.sql.Statement; // requêtes
import java.sql.ResultSet; // un résultat (lignes/colonnes)
import java.sql.SQLException; // une erreur
public class Exemple {
try {
// chargement du pilote
// ouverture de connexion
// exécution d’une requête
// Traitement des résultats
// Fermeture de la connexion
} catch (Exception ex) { }
}

2017-2018
 Connexion à une base de données
 Charger le pilote JDBC avec l’instruction:
Class.forName("com.mysql.jdbc.Driver");

 Dès que le driver a reconnu le gestionnaire de base de données

correspondant (phpMyAdmin par exemple), on réalise une connexion
avec la base de données. On fournit alors l’url de la base, le nom
d'utilisateur et le mot de passe.

String url = "jdbc:SousProtocole:SourceDeDonnées";

Connection con =DriverManager.getConnection(url, "Utilisateur",
"MotDePasse");

2017-2018
 Exemple
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class BaseSQL {
private Connection con;
private Statement st;
public BaseSQL(){
try{
Class.forName("com.mysql.jdbc.Driver");
con= DriverManager.getConnection(
"jdbc:mysql://localhost:3306/base", "root", "root");
st=con.createStatement();
}catch(Exception ex){ System.out.println("Erreur: "+ex); }
}
public static void main(String[] args) { new BaseSQL(); }
} 2017-2018
Les requêtes de sélection
 L'objet Connection créé va permettre d'interagir avec la base. Pour
réaliser des requêtes, on utilise un objet st de type Statement.
Statement st = con.createStatement();
 Le résultat d'une requête est récupéré par un objet res de type interface
ResultSet et permet d'accéder aux données extraites grâce à la requête.
ResultSet res = st.executeQuery("select * from tab");
 Après la requête, le "curseur" est positionné juste avant la première ligne
du résultat. La méthode next() permet d'avancer d'enregistrement en
enregistrement séquentiellement : res.next().
 Pour récupérer les données dans chaque colonne, l'interface ResultSet
propose plusieurs méthodes adaptées aux types de données récupérées :
getString(NumCol), getInt(NumCol), getDate(NumCol)
getString(NomCol), getInt(NomCol), getDate(NomCol)
2017-2018
 Exemple: affichage de données
private Connection con;
private Statement st;
private ResultSet rs;
try{
String requete= "select * from tab";
ResultSet rs= st.executeQuery(requete);
System.out.println("Enregistrements de la table");
while(rs.next()){ // Traitement des résultats
String Nom= rs.getString("nom");
String Prenom= rs.getString("prenom");
int Age= rs.getInt("age");
System.out.println("Nom: "+Nom+" Prenom: "+Prenom+ "Age: "+Age);
}
}catch(Exception ex){
System.out.println("Erreur: "+ex);
} 2017-2018
Les requêtes de mises à jour
 La mise à jour d'une base de données peut être effectuée par une
requête SQL de type INSERT, UPDATE ou DELETE à travers la
méthode executeUpdate("Requête") sur un objet de type Statement.

 Le résultat renvoyé par l'exécution de la requête indiquera le nombre

de lignes mises à jour dans la base, contrairement à une requête de
sélection qui renvoie un ResultSet.

2017-2018
Exemple: Ajout d’un enregistrement
private Connection con;
private Statement st;
private ResultSet rs;
String N="", P="";
int A;
try {
st = con.createStatement();
String requete="INSERT INTO tab(nom,prenom,age)" + "
VALUES('"+N+"','"+P+"','"+A+"')";
// pour ajouter des valeurs déterminées:
//String requete="INSERT INTO tab(nom,prenom,age)" + "
VALUES('saber','Mohammed',20)";
int nb = st.executeUpdate(requete);
} catch (SQLException e1) {
e1.printStackTrace();
} 2017-2018
Exemple:Modifier un enregistrement
try{
String requete="update tab set age=21 where prenom='mohammed'";
int nb = st.executeUpdate(requete);
if (nb!=0)
System.out.println("Table modifiée.");
}catch(Exception ex){
System.out.println("Erreur: "+ex);
}

2017-2018
 Exemple: Modification de la base de
données
 On peut ajouter une nouvelle table Personne à la BD :
 La table Personne contient 4 attributs et une clé primaire non nulle et
auto-incrémentée.
try{
Statement st = con.createStatement();
String requete = "CREATE TABLE Personne(id int not null
auto_increment, nom VARCHAR(15), prenom varchar(15), age
INT, primary key(id))";
st.executeUpdate(requete);

}catch(Exception ex){
System.out.println("Erreur: "+ex);
}

2017-2018
Exemple : Supprimer un enregistrement
try{
String requete= "delete from tab WHERE prenom = 'mohammed'";
int nb = st.executeUpdate(requete);
if (nb!=0)
System.out.println("Enregistrement supprimé.");
}catch(Exception ex){
System.out.println("Erreur: "+ex);
}

2017-2018
Déconnexion
 La méthode close() permet de libérer les ressources prises par la
création d'objets de type ResultSet, Statement et Connection.
 Elle existe pour chacune de ces interfaces. Elle est le plus souvent
employée pour une Connection, car elle libère en même temps toutes
les ressources qui lui sont associées.

try{
if (con != null)
con.close(); // Fermer la connexion
}catch(Exception ex){
System.out.println("Erreur: "+ex);
}

2017-2018
 Exemple complet
 Supposant que nous voulons associer aux boutons des événements:
 Bouton Ajouter enregi: ajoute un enregistrement dans la table tab.
 Bouton Ajouter une table: ajoute une nouvelle table à la BD.
 Bouton Modifier : modifie un enregistrement dans la table tab.
 Bouton Supprimer: supprime un enregistrement dans la table tab.
 Bouton Afficher tab : affiche tous les enregistrement de la table tab.
 Bouton Fermer qui ferme le formulaire.
 Les données à ajouter dans la table seront lues à partir des zones de saisie.
 La table tab contient les champs: nom (String), prenom (String) et age (int).

2017-2018
public Exemple() { // code dans le constructeur
// déclaration des variables de connexion et de l’interface
// connexion avec la base de données
try{
Class.forName("com.mysql.jdbc.Driver");
con=DriverManager.getConnection("jdbc:mysql://localhost:3306/base",
"root","");
st=con.createStatement();
System.out.println("accès avec succès");
}catch(Exception ex){ System.out.println("Erreur: "+ex); }
// fin de a connexion à la base de données
// on associe des écouteurs aux boutons
ajouter.addActionListener(this);
modifier.addActionListener(this);
supprimer.addActionListener(this);
afficher.addActionListener(this);
ajouter_table.addActionListener(this);
2017-2018
 // fermeture du cadre avec confirmation
fermer.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
sortieAvecConf();
}
});
} // fermeture du constructeur

void sortieAvecConf() {
if (JOptionPane.showConfirmDialog(this,
"Voulez-vous vraiment quitter ce programme?",
"Attention!",
JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION)
System.exit(0);
}

2017-2018
public void actionPerformed(ActionEvent arg) {
String N="", P="";
int A;
N= FNom.getText();
P= FPrenom.getText();
A= Integer.parseInt(FAge.getText());//convertir une chaine en int
// affiche des valeurs sur la console
System.out.print(N+P+A);
// ajouter les codes aux boutons
Object source=arg.getSource();
if(source==ajouter){
try {
st = con.createStatement();
String requete="INSERT INTO tab(nom,prenom,age)" + "
VALUES('"+N+"','"+P+"','"+A+"')";
int nb = st.executeUpdate(requete);
} catch (SQLException e1) { e1.printStackTrace(); }
}
2017-2018
if(source==modifier){
try{
String requete="update tab set age=21 where
prenom='mohammed'";
st.executeUpdate(requete);
System.out.println("Table modifiée.");
}catch(Exception ex){ System.out.println("Erreur: "+ex); }
}

if(source==supprimer){
try{
String requete= "delete from tab WHERE prenom =
'Mohammed'";
st.executeUpdate(requete);
System.out.println("Enregistrement supprimé.");
}catch(Exception ex){ System.out.println("Erreur: "+ex); }
}

2017-2018
if(source==afficher){
try{
String requete= "select * from tab";
ResultSet rs= st.executeQuery(requete);
System.out.println("Enregistrements de la table");
while(rs.next()){ // Traitement des résultats
String Nom= rs.getString("nom");
String Prenom= rs.getString("prenom");
int Age= rs.getInt("age");
System.out.println("Nom: "+Nom+" Prenom: "+Prenom+ "Age:
"+Age);
}
}catch(Exception ex){ System.out.println("Erreur: "+ex); }
}

2017-2018
if(source==ajouter_table){
try{
Statement st = con.createStatement();
String requete = "CREATE TABLE Personne(id int not null
auto_increment, prenom VARCHAR(15), nom varchar(15), age
INT, primary key(id))";
st.executeUpdate(requete);

}catch(Exception ex){ System.out.println("Erreur: "+ex); }

}
} // fermeture de la méthode actionPerformed(ActionEvent arg)

2017-2018
SQLException [3]
 Il existe plusieurs classes qui gèrent les exceptions avec les bases de
données.
 La classe la plus importante est SQLException qui traite des erreurs
SQL (syntaxe).

2017-2018
Instruction SQL paramétrée
(PreparedStatement)
[3]

2017-2018
Instruction SQL paramétrée
 La plupart des SGBD ne peuvent analyser qu'une seule fois une
requête, exécutée un grand nombre de fois durant une connexion.

 JDBC permet de profiter de ce type de fonctionnalité par l'utilisation

de requêtes paramétrées.

 Les requêtes paramétrées sont associées aux instances de l'interface

PreparedStatement qui hérite de l'interface Statement.

2017-2018
 Exemple
try {
PreparedStatement ps = con.prepareStatement("SELECT * FROM tab
WHERE nom = ?");
ps.setString(1, "mohammed"); /* l’ordre du nom dans la requête,
1er inconnu */
ps.executeQuery();
} catch (SQLException e1) {
e1.printStackTrace();
}

2017-2018
Requête paramétrée– Valeurs des paramètres

 Les valeurs des paramètres sont données par les méthodes

setXXX(n, valeur).
 On choisit la méthode setXXX suivant le type Java de la valeur
que l'on veut mettre dans la base de données.
 C'est au programmeur de passer une valeur Java du bon type à la
méthode setXXX.
 Le driver JDBC fait la conversion dans le bon format pour le
SGBD.

2017-2018
Avantages des PreparedStatement
 Leur traitement est plus rapide s’ils sont utilisés plusieurs fois avec
différents paramètres.
 Ils améliorent aussi la portabilité car les méthodes setXXX gèrent les
différences entre SGBD.
 En effet, les SGBD n’utilisent pas tous les mêmes formats de date
('JJ/MM/AA' ou 'AAAA-MM-JJ' par exemple) ou de chaînes de
caractères (pour les caractères d’"échappement").
 Ils évitent l'injection de code SQL.

2017-2018
 Références
[1]: http://ivmad.free.fr/cours/IC4-AI-Java.pdf
[2]:http://www.objis.com/formation-java/tutoriel-java-acces-donnees-
jdbc.html
[3]: http://nicolas.durand.perso.luminy.univmed.fr/pub/bd/tpjdbc/JDBC.pdf

2017-2018