Base de données III

Semaine 2 – Communication Java-Oracle avec JDBC

Introduction
• JDBC, Java Data Base Connectivity est un ensemble de classes (API – Application
Programming Interface --JAVA) permettant de se connecter à une base de données
relationnelle en utilisant des requêtes SQL ou des procédures stockées.
• L’API JDBC a été développée de manière à pouvoir se connecter à n’importe quelle
base de données avec la même syntaxe; cette API est dite indépendante du SGBD
utilisé.
• Les classes JDBC font partie du package java.sql et javax.sql
Pourquoi JDBC
• Pendant des années, les programmeurs codais des outils d’accès à des bases de données
en utilisant des outils fournis par les distributeurs de ces bases.
• Ces outils prenaient la forme d’APIs codées en C/C++, ayant des spécifications propres
à elles.
• Le désavantage était que si on voulait changer de SGBD (passer de MySQL à Oracle
par exemple) une grosse partie du code devait être réécrit. Cela peut paraître mineur
dans une petite application, mais dans des applications de grosse taille, cela impliquait
des couts énormes (analyse, modification du code, test unitaire, test de conformité,
etc.).
L'API JDBC permet, entre autres :
• l'établissement d'une connexion avec le SGBD ;
• l'envoi de requêtes SQL au SGBD, à partir du programme Java ;
• le traitement, au niveau du programme, des données retournées par le SGBD ;
• le traitement des métadonnées de la connexion, de l'instruction ou des résultats ;
• le traitement des erreurs retournées par le SGBD lors de l'exécution d'une instruction.
Classes et interfaces de JDBC
• Driver : renvoie une instance de la connexion
• Connexion : connexion à une base de données
• Statement : instruction SQL
• PreparedStatement : instruction SQL paramétrée
• CallableStatement : procédure stockée sur le SGBD
• ResultSet : lignes d’enregistrements récupérées par une instruction SELECT
• ResultSetMetaData : description des lignes d’enregistrements récupérées par une
instruction SELECT
• DataBaseMetaData : informations sur la base de données
• Il faut noter que tous les pilotes JDBC implémentent ces interfaces, c’est pour cette raison
que le code utilisé dans une application ne change pas lorsqu’il y a un changement de
pilote. Ce qui assure une pérennité au niveau du code, et le rend indépendant du pilote
utilisé.
Les pilotes JDBC
• Il existe 4 types de pilotes, cependant pour les fins du cours nous allons aborder
seulement le pilote utilisé pour ORACLE:
 Pilotes Java pur : Permettant d’accéder directement à l’interface de la base de données par le
protocole réseau. Cela permet d’accéder à des bases de données comme MySQL, Oracle, etc.
Les pilotes JDBC
• Ce type de driver est connu sous le nom Direct Database Pure Java Driver), permet
d’accéder directement à la base de données (sans ODBC ni Middleware). C’est le type
le plus optimal et il est complètement écrit en Java.
Installation
• https://www.oracle.com/database/technologies/appdev/jdbc-ucp-19-13-c-downloads.ht
ml
• Ajout du .jar au projet
Installation
• Dans votre projet, ajoutez ensuite le import suivant:
import java.sql.*;

• Puis la connexion:
String url = "jdbc:oracle:thin:@127.0.0.1:1521/XEPDB1";
String user = "patrick";
String password = "Soleil01";
try
{
Connection con = DriverManager.getConnection(url, user, password);
}
catch(SQLException e)
{
System.err.println("Erreur lors de la connexion : "+e);
}
Insert avec JDBC
• Insertion « classique »:
 Statement stmt = conn.createStatement();
stmt.executeUpdate ( "INSERT INTO CLIENT (prenom, nom, courriel, telephone ) VALUES (….)");

• Insertion avec une requête préparée:

 String SQL = "INSERT INTO CLIENT (prenom, nom, courriel, telephone ) VALUES(?,?,?,?)";
PreparedStatement pstmt = conn.prepareStatement(SQL);
pstmt.setString(1, nouveauClient.getPrenom());
pstmt.setString(2, nouveauClient.getNom());
pstmt.setString(3, nouveauClient.getCourriel());
pstmt.setString(4, nouveauClient.getTelephone());
int i=pstmt.executeUpdate();
Select avec JDBC
Statement stmt = conn.createStatement();

String SQL = "SELECT * FROM CLIENT";

ResultSet rs = stmt.executeQuery(SQL);

while(rs.next()){
System.out.print("Id: " + rs.getString("id"));
System.out.print(", Prénom: " + rs.getString("prenom"));
System.out.print(", Nom: " + rs.getString("nom"));
System.out.println(", Courriel: " + rs.getString("courriel"));
System.out.println(", Téléphone: " + rs.getString("telephone"));

}
Update avec JDBC
PreparedStatement ps = conn.prepareStatement("UPDATE CLIENT SET nom=?,
prenom=?, courriel=?, telephone=? WHERE id=?");

ps.setString(1, nom_update_txt.getText());

ps.setString(2, prenom_update_txt.getText());

ps.setString(3, courriel_update_txt.getText());

ps.setString(4, telephone_update_txt.getText());

ps.setString(5, id_update_txt.getText());

ResultSet rs = ps.executeQuery();
Delete avec JDBC
PreparedStatement ps = conn.prepareStatement("DELETE FROM CLIENT WHERE id
= ?");

ps.setString(1, id_update_txt.getText());

ResultSet rs = ps.executeQuery();
Bonnes pratiques avec JDBC
Utilisez les « Prepared Statement »
• L'instruction préparée est utilisée pour exécuter une instruction SQL précompilée. Les
PreparedStatement convient à l'exécution de commandes SELECT, INSERT, UPDATE
et DELETE.
• L'instruction préparée est plus rapide que l'instruction standard, car elle est utilisée pour
exécuter des instructions SQL précompilées. Par conséquent, la même requête SQL peut
être exécutée à plusieurs reprises dans l'instruction préparée.
Désactiver « Auto Commit Mode »
• Il est recommandé d'exécuter une requête SQL avec la désactivation du mode commit
automatique.
• Avec le mode commit automatique désactivé, nous pouvons regrouper les instructions
SQL dans une transaction, tandis que dans le cas du mode de commit automatique
activé, chaque instruction SQL s'exécute sur sa propre transaction et est validée dès
qu'elle se termine. Faire le regroupement améliore les performances.
Utilisez les « batch statements »
• L'API JDBC fournit la méthode addBatch() pour ajouter des requêtes SQL dans un lot
et executeBatch() pour envoyer des requêtes par lots pour exécution.
• La raison derrière cette bonne pratique est que la mise à jour par lots JDBC réduit
potentiellement le nombre d'allers-retours de la base de données, ce qui entraîne un gain
de performances significatif. Utilisez donc toujours la mise à jour par lots JDBC pour
les requêtes d'insertion et de mise à jour.
Accès à l'ensemble de résultats par noms
de colonnes
• L'API JDBC permet d'accéder aux données du ResultSet à l'aide du nom de la colonne
ou de l'index de la colonne.
• Il est suggèré d'utiliser le nom de colonne afin d'éviter l’erreur
InvalidColumnIndexException qui survient si un index de la colonne est incorrect (le
plus courant d'entre eux est 0) car l'index de colonne ResultSet commence à partir de 1
et 0 n'est pas valide.
• Certains peuvent faire valoir que l'accès à une colonne de base de données à l'aide d'un
index est plus rapide qu'un nom, ce qui est vrai. Mais si nous regardons en termes de
maintenance, de robustesse et de lisibilité, accéder à la colonne de la base de données
en utilisant le nom dans l'itérateur ResultSet est préférable.
• resultSetObj.getString(2)
vs
resultSetObj.getString("nom")
Utiliser des variables liées au lieu de la
concaténation
• Comme vu précédemment, il est préférable d'utiliser des PreparedStatement pour
obtenir de meilleures performances. Cependant les performances ne peuvent être
améliorées que si le on utilise des variables liées (?) ou des espaces réservés qui
permettent à la base de données d'exécuter la même requête avec un paramètre
différent.
• En plus d'obtenir de meilleures performances, cette façon de faire offre une protection
contre l'injection SQL.
• Variable liée:
prepStmt = con.prepareStatement("select * from EMPLOYEE where ID=? ");
prepStmt.setInt(1, 8);
• Concaténation:
String query = "select * from EMPLOYEE where id = ";
int i = 2 ;
stmt.executeQuery(query + String.valueOf(i));
Fermer les connexions
• C'est une pratique de codage
courante de fermer n'importe
quelle ressource dans le bloc
finally dès que nous avons fini
d'utiliser la ressource.
• La connexion et les classes JDBC
sont une ressource coûteuse et
doivent être fermées dans le bloc
finally pour garantir la libération
de la connexion même en cas
d'exception SQL.
Mise en cache des instructions
• La mise en cache des instructions améliore les performances en mettant en cache les
instructions exécutables qui sont utilisées à plusieurs reprises, comme dans une boucle.
• L'activation du pool d'instructions permet au pilote JDBC de réutiliser les objets
d'instruction préparée et sont renvoyés au pool au lieu d'être libérés et repréparer.
• Properties propObj = new Properties();
propObj.setProperty("user", "root");
propObj.setProperty("password", "admin@123");
propObj.setProperty("MaxPooledStatements", "250");
Connection connObj = DriverManager.getConnection("jdbc:mysql://localhost:3306/tutorialDb",
propObj);
Utiliser la bonne méthode getX()
• L'interface ResultSet fournit de nombreuses méthodes getX() pour obtenir et convertir
les types de données de base de données en types de données Java et est flexible dans la
conversion de types.
• Par exemple : getString(String columnName) renvoie l'objet Java String.
• La conversion d’un type vers un autre est couteux en terme de performance. Utilisez
donc toujours les méthodes getX() appropriées conformément aux type de données en
BD.
Utiliser des instructions SQL standard
• Il est facile de commencer à utiliser une fonctionnalité spécifique à la base de données
qui peut être présente dans MySQL mais pas dans Oracle, etc.
• En utilisant ANSI SQL ou en n'utilisant pas de SQL spécifique à la base de données,
nous assurons un changement minimal dans la couche applicative en cas de changement
de base de données.
• *** Selon la situation, cela peut être préférable d’utiliser des procédures stockées ou
des fonctions pour la logique applicative plutôt que de l'écrire dans la classe Java. Cette
approche réduit les accès à la base de données et améliore considérablement les
performances des applications. ***

Attention cela dépend de

plusieurs facteurs tel que: -
standard de l’entreprise,
expertise PL/SQL, etc.