0% ont trouvé ce document utile (0 vote)

5 vues65 pages

Accès à une base de données avec JDBC

Le document présente les différentes méthodes d'accès à une base de données en Java, en mettant l'accent sur l'utilisation de l'API JDBC. Il décrit les quatre types de pilotes JDBC, leurs caractéristiques, et explique comment établir une connexion à une base de données, notamment avec MySQL. Enfin, il aborde la manipulation de la connexion, y compris le chargement du pilote et la gestion des ressources.

Transféré par

mr.laurenzoo123

Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.

Formats disponibles

Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

0% ont trouvé ce document utile (0 vote)

5 vues65 pages

Accès à une base de données avec JDBC

Transféré par

mr.laurenzoo123

Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.

Formats disponibles

Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

Samuel KAMDOUM FOLONG

Accès à une base de données à partir de

Java
Lorsque l’on souhaite manipuler une base de données à partir d’un langage de programmation, deux
solutions sont disponibles :

ˇ Communiquer directement avec la base de données.

ˇ Utiliser une couche logicielle assurant le dialogue avec la base de données.

La première solution comporte plusieurs exigences.

ˇ Vous devez parfaitement maîtriser la programmation réseau.

ˇ Vous devez également connaître en détail le protocole utilisé par la base de données.
ˇ Ce type de développement est souvent très long et parsemé d’embûches. Par exemple les
spécifications du protocole sont-elles accessibles ?
ˇ Tout votre travail devra être recommencé si vous changez de type de base de données car les
protocoles ne sont bien sûr pas compatibles d’une base de données à l’autre. Pire parfois
même d’une version à l’autre d’une même base de données.

La deuxième solution est bien sûr préférable et c’est celle-ci que les concepteurs de Java ont choisie. Ils
ont donc développé l’API JDBC (Java DataBase Connectivity) pour l’accès à une base de données. Plus
précisément l’API JDBC est composée de deux parties. La première partie contenue dans le package
[Link] est essentiellement composée d’interfaces. Ces interfaces sont implémentées par le pilote JDBC.
Ce pilote n’est pas développé par Oracle mais en général par le concepteur de la base de données. C’est
effectivement ce dernier qui maîtrise le mieux la technique pour communiquer avec la base de données. Il
existe quatre types de pilotes JDBC avec des caractéristiques et des performances différentes.

ˇ Type 1 : Pilote JDBC-ODBC

Ce type de pilote n’est pas spécifique à une base de données mais il traduit simplement les
instructions jdbc en instructions ODBC. C’est ensuite le pilote odbc qui assure la
communication avec la base de données. Cette solution

n’offre que des performances médiocres. Ceci est principalement lié au nombre de couches
logicielles mises en œuvre. Les fonctionnalités jdbc sont également limitées par les
fonctionnalités de la couche ODBC. Ce type de pilote n’est plus disponible à partir de la version
8 de Java. Oracle recommande l’utilisation du pilote spécifique à la base de données que vous
souhaitez utiliser. Il est généralement disponible sur le site du concepteur de la base de
données.

ˇ Type 2 : Pilote natif

Ce type de pilote n’est pas entièrement écrit en Java. La partie de ce pilote écrite en Java
effectue simplement des appels vers des fonctions du pilote natif. Ces appels sont effectués
grâce à l’API JNI (Java Native Interface). Comme pour les pilotes de type 1, il y a donc une
traduction nécessaire entre le code Java et la base de données. Cependant, ce type de pilote
est tout de même plus efficace que les pilotes JDBC-ODBC.

ˇ Type 3 : pilote utilisant un serveur intermédiaire

Ce pilote développé entièrement en Java ne communique pas directement avec la base de

données mais s’adresse à un serveur intermédiaire. Le dialogue entre le pilote et le serveur
intermédiaire est standard quel que soit le type de base de données. C’est ensuite ce serveur
intermédiaire qui transmet les requêtes en utilisant un protocole spécifique à la base de
données.

ˇ Type 4 : pilote entièrement écrit en Java

Ce type de pilote représente la solution idéale puisqu’il n’y a aucun intermédiaire. Le pilote
transmet directement les requêtes à la base de données en utilisant le protocole propre à la
base de données. La majorité des pilotes sont maintenant de ce type.

1. Présentation de JDBC

L’API JDBC fournit un ensemble de classes et surtout d’interfaces permettant la manipulation d’une base
de données. Ces éléments représentent tout ce dont vous avez besoin pour accéder aux données à partir
d’une application Java.

Le schéma ci-dessous reprend le cheminement logique depuis le pilote jusqu’aux données.

La classe DriverManager est notre point de départ. C’est elle qui assure la liaison avec le pilote. C’est
par son intermédiaire que nous pouvons obtenir une connexion vers la base de données. Celle-ci est
représentée par une instance de classe implémentant l’interface Connection . Cette connexion est
ensuite utilisée pour transmettre des instructions vers la base. Les requêtes simples sont exécutées grâce
à l’interface Statement , les requêtes avec paramètres le sont avec l’interface PreparedStatement
et les procédures stockées avec l’interface CallableStatement .

Les éventuels enregistrements sélectionnés par l’instruction SQL sont accessibles avec un élément
Resultset . Nous allons détailler ces différentes étapes dans les sections suivantes.

2. Chargement du pilote

La première étape indispensable est d’obtenir le pilote JDBC adapté à votre base de

données. En général, ce pilote est disponible en téléchargement sur le site du concepteur de la base de
données. Pour nos exemples, nous utiliserons le pilote fourni par Oracle pour accéder à un serveur de
base de données MySQL. La version 8.0 du pilote (nommé Connector/J) est nécessaire pour utiliser
MySQL 8.0. Il peut être téléchargé à l’adresse suivante : [Link]

Il suffit d’effectuer le téléchargement adapté en fonction de votre système d’exploitation.

Il est aussi possible de télécharger plus simplement ce pilote sur le dépôt Maven à l’adresse suivante :
[Link]

L’écran suivant est affiché. Il permet le téléchargement direct du pilote en cliquant sur jar (2.4MB) ou en
utilisant un gestionnaire de dépendances comme Maven ou Gradle.

Le fichier archive ainsi obtenu ([Link]) contient les classes développées par
Oracle qui implémentent les différentes interfaces JDBC. Ce fichier devra bien sûr être accessible au
moment de la compilation et de l’exécution de l’application.

Pour cela, suivez les étapes suivantes :

 Copier le fichier [Link] dans un répertoire nommé lib dans votre projet.

 Faites un clic droit sur votre projet et sélectionnez le menu Build Path - Configure Build Path….

 Positionnez-vous sur l’onglet Libraries pour afficher l’écran suivant :

 Cliquez sur le bouton Add JARs…. L’écran suivant apparaît :

 Sélectionnez le fichier [Link] dans votre projet et cliquez sur le bouton

OK. L’arborescence de votre projet doit ressembler à celle-ci :

Le répertoire lib contient physiquement le pilote et celui-ci est référencé dans le projet (Referenced
Libraries). Le pilote est utilisable pour le développement et sera disponible dans le classpath à l’exécution.

Le pilote est chargé automatiquement à l’exécution du projet depuis la version 4.0 de l’API JDBC (mise à
disposition depuis Java SE 6).

Auparavant, le pilote devait être chargé grâce à la méthode forName de la classe Class . Cette méthode
attend comme paramètre une chaîne de caractères contenant le nom du pilote. Il est à ce niveau
indispensable de parcourir la documentation du pilote pour obtenir le nom de la classe. Dans notre cas,
cette classe porte le nom suivant :

[Link]

L’enregistrement du pilote se fait donc avec l’instruction suivante :

[Link]("[Link]");

Les chaînes de caractères passées comme paramètres représentent des noms de classes, elles sont
donc sensibles à la casse. L’instruction forName doit d’ailleurs être protégée par un bloc try catch
car elle est susceptible de déclencher une exception de type ClassNotFoundException .

3. Établir et manipuler la connexion

Après son chargement, le pilote est maintenant capable de fournir une connexion vers le serveur de base
de données.

a. Établir la connexion

La méthode getConnection de la classe DriverManager se charge de ce travail. Celle-ci propose

trois solutions pour établir la connexion. Chacune des versions de cette méthode attend comme
paramètre une chaîne de caractères représentant une URL contenant les informations nécessaires pour
établir la connexion. Le contenu de cette chaîne de caractères est spécifique à chaque pilote et il faut à
nouveau consulter la documentation pour obtenir la bonne syntaxe. Le début de cette chaîne de
caractères est

cependant standard avec la forme suivante jdbc:nomDuProtocole . Le nom du protocole est propre
à chaque pilote et c’est grâce à ce nom que la méthode getConnection est capable d’identifier le bon
pilote. Le reste de la chaîne est spécifique à chaque pilote. Il contient en général les informations
permettant d’identifier le serveur et la base de données sur ce serveur vers laquelle la connexion doit être
établie. Pour le pilote MySQL, la syntaxe de base est la suivante :

jdbc:mysql://adresseIP/nomDeLaBasDeDonnees?user=nomUtilisateur&
password=motDePasseUtilisateur;

En cas de succès, la méthode getConnection retourne une instance de classe implémentant

l’interface Connection . Dans certains cas, il est préférable d’utiliser la deuxième version de la méthode
getConnection car celle-ci permet d’indiquer le nom et le mot de passe utilisés pour établir la
connexion comme paramètres séparés de l’URL de connexion.

Voici un exemple permettant d’établir une connexion vers une base de données. Cet exemple part du
principe que vous avez un serveur MySQL installé sur la machine de développement avec une base de
données nommée demo_java et un compte utilisateur mysqluser identifié par le mot de passe Pa$$w0rd.

package [Link];

import [Link];
import [Link];
import [Link];

public class TestConnexion {

public static void main(String[] args) {

String url="jdbc:mysql://localhost/demo_java";
String user="mysqluser";
String password="Pa$$w0rd";
try {
Connection cnx = [Link](url,
user, password);

[Link]("Etat de la connexion :");

[Link]([Link]()?"fermée":"ouverte");
} catch (SQLException e) {
[Link]("Une erreur est survenue lors
de la connexion à la base de données");
[Link]();
}

}
}

Pour que ce code compile, il est nécessaire de charger le module [Link] car il n’est pas chargé par
défaut. Pour cela, il suffit de modifier le fichier [Link] comme ceci :

module ProjetJavaSE_Chapitre6 {
requires [Link];
}

L’exécution de ce programme provoque l’affichage suivant :

Il se peut, en fonction de la configuration de votre machine, que vous obteniez le message d’erreur
suivant :

Cela signifie qu’il y a un problème de détermination du fuseau horaire à utiliser. Il est possible de corriger
le problème en ajoutant un paramètre à la chaîne de connexion :
jdbc:mysql://localhost/demo_java?serverTimezone=UTC

L’autre possibilité est de changer la configuration du serveur MySQL. Pour

cela, positionnez-vous sur l’écran Server Variables depuis MySQL Workbench en cliquant sur le menu
MANAGEMENT - Status and System Variables. Recherchez la propriété time_zone et ajustez-la avec la
valeur souhaitée (+02 :00 dans l’exemple) :

b. Manipuler la connexion

Une connexion est ouverte dès sa création. Il n’y a donc pas de méthode permettant d’ouvrir une
connexion. Cependant, une connexion peut être fermée en appelant la méthode close . Il est important
de le faire lorsque la connexion n’est plus utile pour libérer les ressources engagées. Après la fermeture
d’une connexion, il n’est plus possible de l’utiliser et elle doit être recréée pour pouvoir être à nouveau
utilisable.

L’interface Connection étend l’interface AutoCloseable . Il n’est donc pas nécessaire d’utiliser la
méthode close si le développeur fait usage de l’instruction try with resources . L’exemple suivant
montre l’utilisation d’une telle instruction :

package [Link];

import [Link];
import [Link];
import [Link];

public class TestConnexionTryWithResources {

public static void main(String[] args) {

String url = "jdbc:mysql:
//localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
//Utilisation de l'instruction try with resources
try(Connection cnx = [Link](url,
user, password)) {
[Link]("Etat de la connexion :");
[Link]([Link]() ? "fermée" :
"ouverte");
} //fermeture automatique de la connexion
catch (SQLException e) {
[Link]("Une erreur est survenue
lors de la connexion à la base de données");
[Link]();
}
}
}

La fonction isClosed permet de vérifier si une connexion est fermée. Si cette fonction retourne un
boolean qui est égal à false , on peut donc légitimement penser que la connexion est ouverte et permet
donc de dialoguer avec la base de données. Ce n’est en fait pas toujours le cas. La connexion peut parfois
être dans un état intermédiaire : elle n’est pas fermée mais elle ne peut pas être utilisée pour transférer
des instructions vers le serveur. Pour vérifier la disponibilité de la connexion, vous pouvez utiliser la
méthode isValid . Cette méthode teste réellement la disponibilité de la connexion en essayant
d’envoyer une instruction SQL et en vérifiant qu’elle obtient bien une réponse de la part du serveur. Cette
méthode n’est pas implémentée dans tous les pilotes et si elle ne l’est pas, son appel déclenche une
exception du type [Link] ou une erreur du
type [Link] . Voici le code mettant en évidence l’utilisation de cette
méthode :

public static void testEstValide(Connection cnx) {

boolean estValide;
try {
estValide = [Link](0 );
if (estValide) {
[Link]("La connexion est valide");
} else {
[Link]("La connexion n'est pas valide");
}
} catch ( Exception e) {
[Link]("La méthode isValid n'est pas prise en
charge par le pilote");
[Link]();
}
}

Si vous effectuez uniquement des opérations de lecture sur la base de données vous pouvez optimiser la
communication en précisant que la connexion est en lecture seule. La méthode setReadOnly permet
de modifier ce paramétrage de la connexion. L’état peut ensuite être testé en utilisant la méthode
isReadOnly . Pour certains pilotes cette fonctionnalité n’est pas implémentée et la méthode
setReadOnly n’a aucun effet. La fonction suivante vérifie si cette fonctionnalité est disponible pour la
connexion qui lui est passée comme paramètre.

public static void testLectureSeule(Connection cnx)

{
boolean etat;
try
{
etat = [Link]();
[Link](!etat);
if ([Link]() != etat)
{
[Link]
.println("le mode lecture seule est pris en
charge par ce pilote");
}

else
{
[Link]
.println("le mode lecture seule n'est pas
pris en charge par ce pilote");
}
[Link](etat);
}
catch (SQLException e)
{
[Link]();
}
}

Lors de l’exécution d’une instruction SQL, le serveur peut détecter des problèmes et de ce fait générer des
avertissements. Ces avertissements peuvent être récupérés par la méthode getWarnings de la
connexion. Cette méthode retourne un objet SQLWarning représentatif du problème rencontré par le
serveur. Si plusieurs problèmes sont rencontrés par le serveur celui-ci génère plusieurs objets
SQLWarning chaînés les uns aux autres. La méthode getNextWarning permet d’obtenir l’élément
suivant ou null si la liste est terminée. La liste peut être vidée avec la méthode clearWarnings . La
fonction suivante affiche tous les avertissements reçus par la connexion.

public static void affichageWarnings( Connection cnx)

{
SQLWarning avertissement;
try
{
avertissement=[Link]();
if (avertissement==null)
{
[Link]("il n'y a pas d'avertissement");
}
else
{
while (avertissement!=null)
{

[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
avertissement=[Link]();
}
}
[Link]();
}
catch (SQLException e)
{
[Link]();
}
}

En général, lors de la création de la chaîne de connexion, l’un des paramètres détermine le nom de la base
vers laquelle vous souhaitez établir une connexion. La modification du nom de la base de données à
laquelle vous êtes connecté se réalise avec la méthode setCatalog à laquelle il faut fournir le nom
d’une autre base présente sur le même serveur. Il faut bien sûr que le compte avec lequel vous avez ouvert
la connexion dispose des droits d’accès suffisants pour cette base de données. À noter qu’avec cette
méthode, nous changeons de base de données mais la connexion concerne toujours le même serveur. Il
n’y a aucun moyen de changer de serveur sans créer une nouvelle connexion.

Le code suivant :

public static void changerDeBaseDeDonnes(Connection cnx) {

try {
[Link]("base actuelle : " + [Link]());
[Link]("changement de base de données");
[Link]("demo_java_2");
[Link]("base actuelle : " + [Link]());
} catch (SQLException e) {
[Link]("Problème dans la manipulation
des bases de données sur le serveur");
[Link]();
}
}

affiche le résultat suivant :

base actuelle : demo_java

changement de base de données
base actuelle : demo_java_2

Il faut bien sûr, au préalable, avoir créé une nouvelle base de données nommée demo_java_2 .

La structure de la base peut également être obtenue avec la méthode getMetaData . Cette méthode
retourne un objet de type DatabaseMetaData fournissant de très nombreuses informations sur la
structure de la base. La fonction suivante affiche une analyse rapide de ces informations.

public static void infosBase( Connection cnx)

{
ResultSet rs;
DatabaseMetaData dbmd;
try
{
dbmd=[Link]();
[Link]("type de base : " +
[Link]());
[Link]("version: " +
[Link]());
[Link]("nom du pilote : " +
[Link]());
[Link]("version du pilote : " +
[Link]());
[Link]("nom de l\'utilisateur : " +
[Link]());
[Link]("url de connexion : " + [Link]());
rs=[Link](null,null,"%",null);
[Link]("structure de la base");
[Link]("base\tschema\tnom table\ttype table");
while([Link]())
{
for ( int i = 1 ; i <=4 ; i++)

{
[Link]([Link](i)+"\t");
}
[Link]();
}
[Link]();
rs=[Link](null,null,"%");
[Link]("les procédures stockées");
[Link]("base\tschema\tnom procedure");
while([Link]())
{
for ( int i = 1 ; i <=3 ; i++)
{
[Link]([Link](i)+"\t");
}
[Link]();
}
[Link]();
}
catch (SQLException e)
{
[Link]();
}
}

Vous pouvez observer dans cet exemple l’utilisation d’un objet de type ResultSet . Il permet de lire les
jeux de résultats obtenus auprès du serveur. Une section dédiée est disponible un peu plus loin dans le
chapitre.

Toutes ces méthodes présentées jusque-là peuvent un jour ou l’autre rendre service mais le but principal
d’une connexion est de permettre l’exécution d’instructions SQL. Ce sont les objets de type Connection
qui vont fournir les objets nécessaires pour l’exécution de ces instructions. Trois types d’instructions SQL
peuvent être exécutés :

ˇ Les requêtes simples

ˇ Les requêtes précompilées
ˇ Les procédures stockées.

À chacun de ces types correspond une classe de l’API JDBC :

ˇ
Statement pour les requêtes simples,
ˇ
PreparedStatement pour les requêtes précompilées,
ˇ
CallableStatement pour les procédures stockées.

Et enfin une instance de ces classes peut être obtenue par une méthode différente d’un objet de type
Connection :

ˇ
createStatement pour les objets de type Statement ,
ˇ
prepareStatement pour les objets de type PreparedStatement ,
ˇ
prepareCall pour les objets de type CallableStatement .

L’utilisation de ces méthodes et de ces objets est détaillée dans la section suivante.

4. Exécution d’instructions SQL

Avant l’exécution d’une instruction SQL vous devez choisir le type d’objet le plus approprié. Les rubriques
suivantes décrivent les trois types d’objets disponibles et leur utilisation.

a. Exécution d’instructions de base avec le type Statement

Un objet de ce type est obtenu par la méthode createStatement de la connexion. Deux versions de
cette méthode sont disponibles.

La première n’attend aucun paramètre. Dans ce cas, si l’objet Statement est utilisé pour exécuter une
instruction SQL générant un jeu d’enregistrements (select ), celui-ci sera en lecture seule et avec un
défilement en avant uniquement.

Les informations présentes dans ce jeu d’enregistrements ne pourront pas être modifiées et le parcours
du jeu d’enregistrements ne pourra se faire que du premier enregistrement vers le dernier enregistrement.

La deuxième version permet de choisir les caractéristiques du jeu d’enregistrements

généré. Elle accepte deux paramètres. Le premier détermine le type du jeu d’enregistrements.

Les constantes suivantes sont définies dans la classe ResultSet :

ˇ
ResultSet.TYPE_FORWARD_ONLY : le jeu d’enregistrements sera à défilement en avant
seulement.
ˇ
ResultSet.TYPE_SCROLL_INSENSITIVE : le jeu d’enregistrements pourra être
parcouru dans les deux sens mais sera insensible aux changements effectués dans la base de
données par d’autres utilisateurs.
ˇ
ResultSet.TYPE_SCROLL_SENSITIVE : le jeu d’enregistrements pourra être parcouru
dans les deux sens et sera sensible aux changements effectués dans la base de données par
d’autres utilisateurs.

Le second paramètre détermine les possibilités de modification des informations contenues dans le jeu
d’enregistrements. Les deux constantes suivantes sont définies :

ˇ
ResultSet.CONCUR_READ_ONLY : les enregistrements sont en lecture seule.
ˇ
ResultSet.CONCUR_UPDATABLE : les enregistrements peuvent être modifiés dans le jeu
d’enregistrements.

Cet objet est le plus élémentaire permettant l’exécution d’instructions SQL. Il peut prendre en charge
l’exécution de n’importe quelle instruction SQL. Vous pouvez donc exécuter aussi bien des instructions du
DDL (Data Definition Language) que des instructions du DML (Data Manipulation Language). Il faut
simplement choisir dans cet objet la méthode la plus adaptée pour l’exécution du code SQL. Le choix de
cette méthode est dicté par le type de résultat que doit fournir l’instruction SQL. Quatre méthodes sont
disponibles :

ˇ
public boolean execute(String sql) : cette méthode permet l’exécution de
n’importe quelle instruction SQL. Le boolean retourné par cette méthode indique si un jeu
d’enregistrements a été généré (true ) ou si simplement l’instruction a modifié des
enregistrements dans la base de données (false ). Si un jeu d’enregistrements est généré, il
peut être obtenu par la méthode getResultSet . Si des enregistrements ont été modifiés
dans la

base de données, la méthode getUpdateCount retourne le nombre d’enregistrements

modifiés. La fonction suivante illustre l’utilisation de ces méthodes.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestStatement {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
Statement stm =
[Link](ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY)) {

BufferedReader br =
new BufferedReader(new InputStreamReader([Link]));
[Link]("saisir votre
instruction SQL :");
String requete = [Link]();
boolean resultat = [Link](requete);
//Si vrai, il y a eu un résultat
if (resultat) {
[Link]("votre instruction a généré
un jeu d\'enregistrements");
//Récupération du jeu de résultats
ResultSet rs = [Link]();
//Positionnement sur le dernier
enregistrement
[Link]();
//Lecture de numéro de la ligne
[Link]("il contient " +

[Link]() + " enregistrements");

//si faux, il y a peut-être eu une mise à jour
} else {
[Link]("votre instruction a
modifié des enregistrements dans la base");
[Link]("nombre
d'enregistrements modifiés :" + [Link]());
}
} catch (SQLException e) {
[Link]("votre instruction n\'a pas
fonctionné correctement");
} catch (IOException e) {
[Link]();
}
}

private static Connection getConnexion() throws SQLException{

String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}

L’exécution de ce code avec une requête comportant des erreurs provoque le résultat suivant :

L’exécution de ce code avec une requête de type select provoque le résultat suivant :

Pour l’exemple, une table PERSONNES a été créée avec le script suivant :

use demo_java;
create table PERSONNES(
id int auto_increment primary key,
nom varchar( 30) not null,
prenom varchar( 30) not null,
dateDeNaissance date
);

Un enregistrement a été ajouté :

insert into PERSONNES(nom,prenom,dateDeNaissance)

values( "McQueen", "Steeve", "1930-03-24")

Pour terminer, l’exécution de ce code avec une requête d’insertion provoque le résultat suivant :

ˇ
public Resultset executeQuery(String requete) : cette méthode est conçue
spécialement pour l’exécution d’instructions select . Le jeu d’enregistrements est disponible
directement comme valeur retournée par la fonction.
ˇ
public int executeUpdate(String requŒte) : cette méthode est parfaitement
adaptée pour l’exécution d’instructions modifiant le contenu de la base de données comme les
instructions insert , update , delete . L’entier

retourné par cette fonction indique le nombre d’enregistrements affectés par la modification.
ˇ
public int[] executeBatch() : cette méthode permet d’exécuter un ensemble
d’instructions SQL par lot. Le lot d’instructions à exécuter doit être préparé au préalable avec
les méthodes addBatch et clearBatch . La première reçoit comme paramètre une chaîne
de caractères représentant une instruction SQL à ajouter au lot. La seconde permet de
réinitialiser le lot d’instructions. Il n’est pas possible de supprimer une instruction particulière
du lot. Vous ne devez pas ajouter au lot d’instruction SQL générant un jeu de résultats, car dans
ce cas la méthode updateBatch déclenche une exception de type
BatchUpdateException . Cette fonction retourne un tableau d’entiers permettant d’obtenir
une information sur l’exécution de chacune des requêtes du lot. Chaque case du tableau
contient un entier représentatif du résultat de l’exécution de la requête correspondante dans le
lot. Une valeur supérieure ou égale à 0 indique un fonctionnement correct de l’instruction et
représente le nombre d’enregistrements modifiés. Une valeur égale à la constante
Statement.EXECUTE_FAILED indique que l’exécution de l’instruction a échoué. Dans ce
cas, certains pilotes arrêtent l’exécution du lot alors que d’autres continuent avec l’instruction
suivante du lot. Une valeur égale à la constante Statement.SUCCESS_NO_INFO indique
que l’instruction a été exécutée correctement mais que le nombre d’enregistrements modifiés
ne peut pas être déterminé. Cette méthode est très pratique pour exécuter des modifications
sur plusieurs tables liées. Ce pourrait par exemple être le cas dans une application de gestion
de commerciale avec une table pour les commandes et une table pour les lignes de
commande. La suppression d’une commande doit dans ce cas entraîner la suppression de
toutes les lignes correspondantes. La fonction suivante vous permet de saisir plusieurs
instructions SQL et de les exécuter par lot.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];

public class TestStatementBatch {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
Statement stm = [Link]
(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY)) {

BufferedReader br =
new BufferedReader(new InputStreamReader([Link]));
[Link]("saisir vos instructions SQL
puis run pour exécuter le lot :");
String requete = [Link]();
while (![Link]("run")) {
[Link](requete);
requete = [Link]();
}
[Link]("exécution
du lot d'instructions");
int[] resultats = [Link]();
for (int i = 0 ; i < [Link]; i++) {
switch (resultats[i]) {
case Statement.EXECUTE_FAILED:
[Link]("l'exécution
de l'instruction " + i + " a échoué");
break;
case Statement.SUCCESS_NO_INFO:
[Link]("l'exécution
de l'instruction " + i + " a réussi");
[Link]("le nombre
d'enregistrements modifiés est inconnu");
break;
default:
[Link]("l'exécution
de l'instruction " + i + " a réussi");
[Link]("elle a

modifié " + resultats[i] + " enregistrements");

break;
}
}

} catch (SQLException e) {
[Link]("votre batch n'a pas
fonctionné correctement");
} catch (IOException e) {
[Link]();
}
}

private static Connection getConnexion() throws SQLException {

String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}

L’exécution de code avec des instructions SQL valides donne le résultat suivant :

Plusieurs autres méthodes vont intervenir sur le comportement de l’objet Statement :

ˇ
public void setQueryTimeOut(int duree) : cette méthode indique la durée
maximale allouée pour l’exécution d’une instruction SQL avant le déclenchement d’une
exception.

ˇ
public void close() : lorsqu’un objet Statement n’est plus utile dans une
application, il est préférable de le fermer explicitement en appelant cette méthode. Celle-ci
provoque la libération de toutes les ressources utilisées par cet objet. La fermeture d’un objet
Statement provoque également la fermeture du jeu d’enregistrements associé
(ResultSet ). Tout comme l’interface Connection , l’interface Statement hérite de
l’interface AutoCloseable . Il est donc possible (comme le montrent les exemples)
d’initialiser ce type d’objet dans une instruction try with resources pour provoquer sa fermeture
automatique à la fin du bloc try .
ˇ
public void setMaxRows(int nombre) : cette méthode limite le nombre de lignes
des jeux d’enregistrements générés par cet objet Statement . Si une instruction SQL génère
un jeu d’enregistrements comportant plus de lignes, les lignes excédentaires sont tout
simplement ignorées (sans plus d’information).
ˇ
public void setMaxFieldSize(int taille) : cette méthode limite la taille de
certains types de champs dans le jeu d’enregistrements. Les types de champs concernés sont
les champs d’une base de données pouvant avoir une taille variable comme par exemple les
champs caractères ou binaires. Les données excédentaires sont simplement ignorées. Les
champs concernés peuvent de ce fait être inutilisables dans l’application.
ˇ
public void setFetchSize(int nbLignes) : lorsqu’une instruction SQL génère un
jeu d’enregistrements, les données correspondantes sont transférées du serveur de base de
données vers la mémoire de l’application Java. Ce transfert est effectué par blocs en fonction
de l’utilisation des données. Cette méthode indique au pilote le nombre de lignes de chaque
bloc transféré de la base de données vers l’application.
ˇ
public boolean getMoreResults() : si la méthode execute est utilisée pour
exécuter plusieurs instructions SQL, par exemple deux instructions select , il y a dans ce cas
génération de deux jeux d’enregistrements. Le premier est obtenu par la méthode
getResultSet . Le second ne sera accessible qu’après avoir appelé la méthode
getMoreResults . Cette fonction permet de déplacer le pointeur sur le résultat suivant et
retourne un boolean égal à true si le résultat suivant est un jeu d’enregistrements. Si c’est
le cas, il

est lui aussi accessible par la méthode getResultSet . Si la fonction getMoreResults

retourne un boolean égal à false , c’est que le résultat suivant n’est pas un jeu
d’enregistrements ou qu’il n’y a simplement pas de résultat suivant. Pour lever le doute, il faut
donc appeler la fonction getUpdateCount et vérifier la valeur retournée par cette fonction.
Si cette valeur est égale à -1 c’est qu’il n’y a pas de résultat suivant sinon la valeur retournée
représente le nombre d’enregistrements modifiés dans la base de données.

La fonction suivante permet l’exécution de plusieurs instructions SQL séparées par des points-virgules :

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestStatementGetMoreResults {

public static void main(String[] args) {

boolean resultat;
ResultSet rs;
try (Connection cnx = getConnexion();
Statement stm = [Link]
(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY)) {

BufferedReader br =
new BufferedReader(new InputStreamReader([Link]));
[Link]("saisir vos instructions SQL
séparées par ; :");
String requete = [Link]();
resultat = [Link](requete);
int i = 1 ;

// traitement du résultat généré par la première

// instruction
if (resultat) {
[Link]("votre instruction N°
" + i + " a généré un jeu d'enregistrements");
rs = [Link]();
[Link]();
[Link]("il contient " +
[Link]() + " enregistrements");
} else {
[Link]("votre instruction
N° " + i + " a modifié des enregistrements dans la base");
[Link]("nombre
d'enregistrements modifiés :" + [Link]());
}
i++;
// déplacement du pointeur sur un éventuel résultat
// suivant
resultat = [Link]();
// boucle tant qu'il y a encore un résultat
de type jeu
// d'enregistrement -> resultat==true
// ou qu'il y a encore un résultat de type nombre
// d'enregistrements modifiés -> getUpdateCount != -1
while (resultat || [Link]() != -1) {
if (resultat) {
[Link]("votre instruction
N° " + i + " a généré un jeu d\'enregistrements");
rs = [Link]();
[Link]();
[Link]("il contient " +
[Link]() + " enregistrements");
} else {
[Link]("votre instruction
N° " + i + " a modifié des enregistrements dans la base");
[Link]("nombre
d'enregistrements modifiés :" + [Link]());
}
i++;
// déplacement du pointeur

sur un éventuel résultat

// suivant
resultat = [Link]();
}
} catch (SQLException e) {
[Link]("votre instruction
n'a pas fonctionné correctement");
[Link]();

} catch (IOException e) {
[Link]();
}
}

private static Connection getConnexion() throws SQLException {

String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC&allowMultiQueries=true";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}

Notez la modification de la chaîne de connexion dans la méthode getConnexion de l’exemple :

String url = "jdbc:mysql://localhost/demo_java?serverTimezone=

UTC&allowMultiQueries=true";

Pour que l’exécution de requêtes multiples fonctionne avec MySQL, il est nécessaire d’ajouter le paramètre
allowMultiQueries avec la valeur true .

Voici un exemple d’exécution de ce programme :

b. Exécution d’instructions paramétrées avec l’objet PreparedStatement

Il arrive fréquemment d’avoir à faire exécuter plusieurs fois une requête SQL avec juste une petite
modification entre deux exécutions. L’exemple classique correspond à une requête de sélection avec une
restriction.

String requete = "select * from PERSONNES where nom = 'McQueen'";

La valeur sur laquelle porte la restriction est en général saisie par l’utilisateur de l’application et dans ce
cas disponible dans une variable. La première solution qui vient à l’esprit consiste à construire la requête
SQL par concaténation de plusieurs chaînes de caractères.

String requete = "select * from PERSONNES where nom = '" + nomSaisie + "'";

Cette solution présente plusieurs inconvénients :

ˇ La concaténation de chaînes de caractères consomme beaucoup de ressources.

ˇ Le serveur doit analyser à chaque fois une nouvelle requête.
ˇ La syntaxe va rapidement devenir complexe si plusieurs chaînes doivent être concaténées. Il
faut toujours conserver à l’esprit qu’au final nous devons obtenir une instruction SQL correcte.
ˇ Enfin, la concaténation peut entraîner des risques d’injections SQL qui détourneraient le rôle
initial de la requête. Imaginons la requête permettant d’identifier une personne par son login et
son mot de passe saisis dans un formulaire. Elle pourrait être de la forme suivante :

String requete = "select * from PERSONNES where login = '" +

loginSaisie + "' and motDePasse = '" + motDePasseSaisie + "'";

Si l’utilisateur saisit les valeurs « admin » et « mdp1234 », alors la requête générée est la suivante :

Select * from PERSONNES where login = 'admin' and motDePasse = 'mdp1234'

En revanche, si l’utilisateur saisit les valeurs « admin » et « ’ or ’a’=’a », alors la requête générée est la
suivante :

Select * from PERSONNES where login = 'admin' and motDePasse = '' or 'a'= 'a' ;

La requête prend un autre aspect et le comportement est changé. Un pirate peut ainsi se connecter
sans connaître le mot de passe de l’utilisateur. C’est ce que l’on appelle une injection SQL. La faille
dans cet exemple est d’interpréter la quote saisie par l’utilisateur comme un élément de la syntaxe
SQL. Il faut échapper le caractère pour indiquer qu’il doit être interprété comme un caractère textuel
uniquement.

Les concepteurs de JDBC ont prévu une solution efficace pour pallier ces inconvénients. L’objet
PreparedStatement apporte une solution efficace à ce problème en permettant la création de
requêtes avec paramètres. Dans ce type de requête, les paramètres sont remplacés par des points
d’interrogation. Avant l’exécution de la requête, il faut fournir à l’objet PreparedStatement les valeurs
qu’il doit utiliser pour remplacer les différents points d’interrogation. Un objet PreparedStatement
peut être créé en utilisant le même principe que pour la création d’un objet Statement .

La méthode prepareStatement accessible à partir d’une connexion retourne un objet

PreparedStatement . Cette méthode est disponible sous deux formes. La première attend comme
argument une chaîne de caractères représentant la requête SQL. Dans cette requête, l’emplacement des
paramètres doit être réservé par des points d’interrogation. Si un jeu d’enregistrements est créé par
l’exécution de cette requête, celui-ci sera en lecture seule et à défilement en avant seulement. La deuxième
forme de la

méthode prepareStatement attend en plus de la chaîne de caractères un argument indiquant le type

de jeu d’enregistrements et un autre déterminant les possibilités de modification des informations
contenues dans le jeu d’enregistrements.

Les mêmes constantes que pour la méthode createStatement peuvent être utilisées.

PreparedStatement pstm = [Link]("select * from

PERSONNES where nom = ?", ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY);

Avant l’exécution de l’instruction SQL, vous devez fournir une valeur pour chacun des points
d’interrogation représentant un paramètre. Pour cela, l’objet PreparedStatement dispose de
nombreuses méthodes permettant l’affectation d’une valeur à un paramètre. Chacune de ces méthodes
correspond au type de données SQL à insérer à la place d’un point d’interrogation. Ces méthodes sont
nommées selon le même schéma : setXxx où Xxx représente un type de données SQL. Chacune de ces
méthodes attend comme premier argument un entier correspondant au rang du paramètre dans
l’instruction SQL. Le premier paramètre est situé au rang 1. Le deuxième argument correspond à la valeur
à transférer dans le paramètre. Le type de cet argument correspond bien sûr au type de données SQL à
transférer vers le paramètre. Le pilote JDBC convertit ensuite le type Java en type SQL.

Par exemple la méthode setInt (int indiceParam, int value) effectue une conversion du
type int Java en type INTEGER SQL. Chaque fournisseur d’un pilote JDBC met à disposition une
documentation listant les relations existantes entre les types Java et les types SQL. Cette documentation
pour le pilote JDBC est disponible à l’adresse suivante : [Link]
j/8.0/en/[Link]

Les valeurs stockées dans les paramètres sont conservées d’une exécution à l’autre de l’instruction SQL.
La méthode clearParameters permet de réinitialiser l’ensemble des paramètres.

Les paramètres peuvent être utilisés dans une instruction SQL en remplacement de valeurs mais jamais
pour remplacer un nom de champ, encore moins un opérateur. La syntaxe suivante est bien sûr interdite :

PreparedStatement pstm = [Link]("select * from

PERSONNES where ? = ?", ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY);
[Link](1,"nom");
[Link](2,"McQueen");
rs=[Link]();

Les autres méthodes disponibles avec un objet PreparedStatement sont parfaitement identiques à
celles définies pour un objet Statement puisque l’interface PreparedStatement hérite directement
de l’interface Statement . L’exemple suivant permet d’afficher la liste des personnes répondant au nom
fourni par l’utilisateur de l’application.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestPreparedStatement {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
PreparedStatement pstm =
[Link]("select * from PERSONNES where nom = ?",
ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY)) {

BufferedReader br =
new BufferedReader(new InputStreamReader([Link]));
[Link]("saisir le nom
de la personne recherchée :");
String nom = [Link]();

//Appliquer les paramètres

[Link](1 , nom);
//Exécuter la requête et obtenir le résultat
ResultSet rs = [Link]();
//Tant qu'il y a des enregistrements
while ([Link]()) {
//Boucler sur le nombre de colonnes
pour afficher les informations
for (int i = 1 ; i <=
[Link]().getColumnCount(); i++) {
[Link]([Link](i) + "\t");
}
[Link]();
}
} catch (SQLException e) {
[Link]();
} catch (IOException e) {
[Link]();
}

private static Connection getConnexion() throws SQLException {

String url = "jdbc:mysql://localhost/
demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}

L’exécution de ce programme donne le résultat suivant :

Le type PreparedStatement est aussi largement utilisé pour les opérations d’écriture (insert ,
update , delete ). Dans le cadre de l’insertion, une fonctionnalité très appréciable permet de récupérer
l’éventuelle clé auto-générée par la base de données (c’est typiquement le cas pour une clé primaire de
type auto-incrément).

Pour récupérer la clé auto-générée, il faut utiliser la deuxième signature de la méthode

prepareStatement de l’objet de type Connection . Cette méthode attend en paramètre une chaîne
de caractères correspondant à la requête paramétrée suivi d’un entier indiquant si le développeur souhaite
récupérer la clé auto-générée par la base. La constante Statement.RETURN_GENERATED_KEYS
permet de le spécifier.

L’exécution de la requête paramétrée avec la méthode executeUpdate de l’interface

PreparedStatement permet de valoriser un ResultSet contenant un seul enregistrement avec la
clé auto-générée. L’accès à ce ResultSet se fait au travers de la méthode getGeneratedKeys de
l’interface Statement dont dérive l’interface PreparedStatement . La clé est disponible dans la
première colonne de l’unique enregistrement du ResultSet .

Le code suivant met en évidence cette fonctionnalité.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestInsertionViaPreparedStatement {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
//Requête d'insertion

avec les champs obligatoires

PreparedStatement pstm =
[Link]("insert into PERSONNES(nom, prenom) values(?,?)",
Statement.RETURN_GENERATED_KEYS)) {

BufferedReader br =
new BufferedReader(new InputStreamReader([Link]));
[Link]("saisir le nom de la personne
à ajouter :");
String nom = [Link]();
[Link]("saisir le prénom de la personne
à ajouter :");
String prenom = [Link]();
//Appliquer les paramètres
[Link](1 , nom);
[Link](2 , prenom);
//Exécuter la requête et obtenir le résultat
[Link]();
//Récupérer le ResultSet contenant
éventuellement une clé
ResultSet rsCleGeneree = [Link]();
//S'il y a un enregistrement, c'est qu'il y a une clé
if([Link]())
{
[Link]("La clé
de l'enregistrement générée est " + [Link](1 ));
}
} catch (SQLException e) {
[Link]();
} catch (IOException e) {
[Link]();
}
}

private static Connection getConnexion() throws SQLException {

String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);

L’exécution de ce programme donne le résultat suivant :

c. Exécution de procédures stockées avec l’objet CallableStatement

Une procédure stockée représente du code SQL stocké sur le serveur. Cette approche procure plusieurs
avantages :

ˇ Les traitements et les temps de réponse sont améliorés.

ˇ Le code SQL peut être partagé entre plusieurs applications.

En revanche, les applications deviennent beaucoup plus dépendantes du serveur de base de données. Le
changement de serveur vous obligera certainement à réécrire vos procédures stockées car la syntaxe
d’une procédure stockée est propre à chaque serveur. Les procédures stockées sont accessibles à partir
de Java grâce à l’objet CallableStatement . Comme pour les objets Statement et
PreparedStatement , c’est encore une fois la connexion qui va fournir une instance de cette classe.
C’est dans ce cas la méthode prepareCall qui doit être utilisée. Cette méthode attend comme
argument une chaîne de caractères identifiant la procédure stockée à appeler. Par contre la syntaxe de
cette chaîne de caractères est un petit peu spéciale puisqu’il ne suffit pas d’indiquer le nom de la
procédure stockée :

{call nomProcedure( ?, ?,...)}

Dans cette syntaxe, les points d’interrogation représentent les paramètres attendus par la procédure
stockée. Comme pour l’objet PreparedStatement les valeurs de ces paramètres doivent être fournies
par les méthodes setXxx correspondantes au type du paramètre.

Pour les paramètres utilisés en sortie de la procédure stockée (paramètres tagués avec le mot-clé out ),
c’est l’exécution de la procédure stockée qui va y stocker une valeur, vous devez en informer l’objet
CallableStatement en appelant la méthode registerOutParameter . Cette méthode attend
comme premier argument, l’indice du paramètre de retour de la procédure stockée, puis comme deuxième
argument le type SQL du paramètre. Ce type peut être indiqué avec une des constantes définies dans
l’interface [Link] . Après exécution de la procédure stockée, la valeur des
paramètres utilisés en sortie est accessible par les méthodes getXxx où Xxx représente le type SQL du
paramètre. Ces méthodes attendent comme argument l’indice du paramètre dans l’appel de la procédure
stockée.

Comme pour les méthodes createStatement et prepareStatement , la méthode prepareCall

propose une deuxième syntaxe permettant d’indiquer les caractéristiques d’un éventuel jeu
d’enregistrements généré par l’exécution de la procédure stockée.

Pour illustrer l’utilisation de l’objet CallableStatement , nous allons utiliser la procédure stockée
suivante :

CREATE DEFINER=`mysqluser`@ `localhost` PROCEDURE

`nombrePersonnesParNom`( in tri varchar( 4 ), out nombreTotal integer)
BEGIN
select count(*) into nombreTotal from PERSONNES;
if(tri='ASC')then
select count(*) as nombrePersonnes,
nom from PERSONNES group by nom asc;
else
select count(*) as nombrePersonnes,
nom from PERSONNES group by nom desc;
end if;
END

La procédure renvoie un jeu d’enregistrements composé des noms des personnes et du

nombre de personnes pour chaque nom. Ce jeu d’enregistrements est trié selon le premier paramètre de la
procédure. Le second paramètre est de type out . Il permet de retourner à l’appelant le nombre total de
personnes.

Le code suivant permet d’exécuter cette procédure stockée et d’exploiter les résultats :

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestCallableStatement {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
CallableStatement cstm =
[Link]("{call nombrePersonnesParNom ( ?, ? )}",
ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY)) {
[Link]("saisir le tri
du résultat (ASC ou DESC) :");
BufferedReader br =
new BufferedReader(new InputStreamReader([Link]));
String tri = [Link]();
// Application des paramètres
[Link](1 , tri);
[Link](2 , [Link]);
// Exécution de la requête
boolean existeResultat = [Link]();
// Récupération du paramètre du type out
int nombrePersonnes = [Link](2 );
[Link]("nombre de personnes:
" + nombrePersonnes);

if (existeResultat) {
ResultSet rs = [Link]();
while ([Link]()) {
[Link]([Link]("nom")
+ ": " + [Link]("nombrePersonnes") + " personnes");
}
}
} catch (SQLException e) {
[Link]();
} catch (IOException e) {
[Link]();
}

private static Connection getConnexion() throws SQLException {

String url = "jdbc:mysql://localhost/
demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}

L’exécution de ce programme donne le résultat suivant :

5. Utilisation des jeux d’enregistrements avec l’interface ResultSet

Lorsqu’une instruction SQL select est exécutée par la méthode executeQuery d’un objet
Statement , PreparedStatement ou CallableStatement , celle-ci retourne un objet
ResultSet . C’est par l’intermédiaire de cet objet ResultSet que nous allons pouvoir intervenir sur le
jeu d’enregistrements. Nos possibilités d’action sur ce jeu d’enregistrements sont déterminées par les
caractéristiques de l’objet ResultSet . Ces caractéristiques sont fixées au moment de la création des
objets Statement , PreparedStatement ou CallableStatement en fonction des arguments
passés lors de l’appel des méthodes createStatement , prepareStatement ou prepareCall .

Le premier argument détermine le type du jeu d’enregistrements. Les constantes suivantes sont définies :

Le second argument détermine les possibilités de modification des informations contenues dans le jeu
d’enregistrements. Les deux constantes suivantes sont définies :

ˇ
ResultSet.CONCUR_READ_ONLY : les enregistrements sont en lecture seule.
ˇ
ResultSet.CONCUR_UPDATABLE : les enregistrements peuvent être modifiés dans le jeu
d’enregistrements.

Il faut bien sûr que les actions exécutées sur l’objet Resultset soit compatibles avec

ces caractéristiques sinon une exception sera déclenchée. Il est possible de vérifier les caractéristiques
d’un objet Resultset en utilisant les méthodes getType et getConcurrency . Le code suivant
affiche les caractéristiques du ResultSet . Il est disponible dans la classe TestTypeResultSet du
package [Link] .

private static void afficherTypeResultSet(ResultSet rs) {

try {
switch ([Link]()) {
case ResultSet.TYPE_FORWARD_ONLY:
[Link]("le ResultSet
est à défilement en avant seulement");
break;
case ResultSet.TYPE_SCROLL_INSENSITIVE:
[Link]("le ResultSet
peut être parcouru dans les deux sens");
[Link]("il n'est pas sensible
aux modifications faites par d'autres utilisateurs");
break;
case ResultSet.TYPE_SCROLL_SENSITIVE:
[Link]("le ResultSet
peut être parcouru dans les deux sens");
[Link]("il est sensible
aux modifications faites par d'autres utilisateurs");
break;
}
switch ([Link]()) {
case ResultSet.CONCUR_READ_ONLY:
[Link]("les données contenues
dans le ResulSet sont en lecture seule");
break;
case ResultSet.CONCUR_UPDATABLE:
[Link]("les données contenues
dans le ResulSet sont modifiables");
break;
}
} catch (SQLException e) {
[Link]();
}

a. Positionnement dans un ResultSet

L’objet ResultSet gère un pointeur d’enregistrement déterminant sur quel enregistrement vont intervenir
les méthodes exécutées sur le ResultSet lui-même. Cet enregistrement est parfois appelé
enregistrement actif ou enregistrement courant. L’objet ResultSet contient toujours deux
enregistrements fictifs servant de repère pour le début du ResultSet (BOF - Beginning Of File) et pour la
fin du ResultSet (EOF - End Of File). Le pointeur d’enregistrement peut être positionné sur l’un de ces
deux enregistrements mais jamais avant l’enregistrement BOF ni après l’enregistrement EOF. Ces
enregistrements ne contiennent pas de données et une opération de lecture ou d’écriture sur ces
enregistrements déclenche une exception. À la création du ResultSet le pointeur est positionné avant le
premier enregistrement (BOF). Lorsque le jeu d’enregistrements ne contient aucun résultat, il y a
forcément ces deux enregistrements fictifs.

De nombreuses méthodes sont disponibles pour gérer le pointeur d’enregistrements :

ˇ
boolean absolute(int position) : déplace le pointeur d’enregistrement sur
l’enregistrement spécifié. La numérotation des enregistrements débute à 1. Si la valeur de
l’argument position est négative, le déplacement est effectué en partant de la fin du
ResultSet . Si le numéro d’enregistrement n’existe pas le pointeur est positionné sur
l’enregistrement BOF si la valeur est négative et inférieure au nombre d’enregistrements ou sur
l’enregistrement EOF si la valeur est positive et supérieure au nombre d’enregistrements. Cette
méthode retourne true si le pointeur est positionné sur un enregistrement valide et false
dans le cas contraire (BOF ou EOF).
ˇ
boolean relative(int deplacement) : déplace le ponteur du nombre
d’enregistrements spécifié par l’argument deplacement . Si la valeur de cet argument est
positive le curseur descend dans le jeu d’enregistrements et si la valeur est négative le curseur
remonte dans le jeu d’enregistrements. Cette méthode retourne true si le pointeur est
positionné sur un enregistrement valide et false dans le cas contraire (BOF ou EOF).

ˇ
void beforeFirst() : déplace le pointeur d’enregistrements avant le premier
enregistrement (BOF).
ˇ
void afterLast() : déplace le pointeur d’enregistrements après le dernier enregistrement
(EOF).
ˇ
boolean first() : déplace le pointeur d’enregistrements sur le premier enregistrement.
Cette méthode retourne true s’il y un enregistrement dans le ResultSet et false dans le
cas contraire.
ˇ
boolean last() : déplace le pointeur d’enregistrements sur le dernier enregistrement.
Cette méthode retourne true s’il y un enregistrement dans le ResultSet et false dans le
cas contraire.
ˇ
boolean next() : déplace le pointeur d’enregistrements sur l’enregistrement suivant
l’enregistrement courant. Cette méthode retourne true si le pointeur est sur un
enregistrement valide et false dans le cas contraire (EOF).
ˇ
boolean previous() : déplace le pointeur d’enregistrements sur l’enregistrement
précédant l’enregistrement courant. Cette méthode retourne true si le pointeur est sur un
enregistrement valide et false dans le cas contraire (BOF).

Pour toutes ces méthodes sauf pour la méthode next , il faut obligatoirement que le ResultSet soit de
type SCROLL_SENSITIVE ou SCROLL_INSENSITIVE . Si le ResultSet est de type
FORWARD_ONLY , seule la méthode next fonctionne et dans ce cas les autres méthodes déclenchent
une exception. Les méthodes suivantes permettent de tester la position du pointeur d’enregistrements :

ˇ
boolean isBeforeFirst() : retourne true si le pointeur est placé avant le premier
enregistrement (BOF).
ˇ
boolean isAfterLast() : retourne true si le pointeur est placé après le dernier
enregistrement (EOF).
ˇ
boolean isFirst() : retourne true si le pointeur est placé sur le
premier enregistrement.
ˇ
boolean isLast() : retourne true si le pointeur est placé sur le dernier

enregistrement.
ˇ
int getRow() : retourne le numéro de l’enregistrement sur lequel se trouve le pointeur
d’enregistrements. La valeur 0 est retournée s’il n’y a pas d’enregistrement courant (BOF ou
EOF).

Le programme suivant permet d’afficher la position du pointeur sur le ResultSet :

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestPositionPointeurResultSet {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
Statement stm = [Link]
(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE)) {

// Exécuter la requête et obtenir le résultat

ResultSet rs = [Link]("select *
from PERSONNES");

afficherPositionPointeur(rs);
// Tant qu'il y a des enregistrements
while ([Link]()) {
afficherPositionPointeur(rs);
}
afficherPositionPointeur(rs);
} catch (SQLException e) {
[Link]();
}

private static void afficherPositionPointeur(ResultSet rs) {

try {
if ([Link]()) {
[Link]("le pointeur
est avant le premier enregistrement");
}
if ([Link]()) {
[Link]("le pointeur est
après le dernier enregistrement");
}
if ([Link]()) {
[Link]("le pointeur est
sur le premier enregistrement");
}
if ([Link]()) {
[Link]("le pointeur est
sur le dernier enregistrement");
}
int position;
position = [Link]();
if (position != 0 ) {
[Link]("c'est
l'enregistrement numéro " + position);
}
} catch (SQLException e) {
[Link]();
}
}

private static Connection getConnexion() throws SQLException {

String url = "jdbc:mysql:
//localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}

L’exécution de ce code permet d’avoir le résultat suivant à l’exécution :

b. Lecture des données dans un ResultSet

L’objet ResultSet fournit de nombreuses méthodes permettant la lecture des champs d’un
enregistrement. Chacune de ces méthodes est spécifique à un type de données SQL. Il faut bien sûr
utiliser en priorité la méthode adaptée au type du champ dont on souhaite obtenir la valeur. Cependant
certaines de ces méthodes sont relativement souples et permettent la lecture de plusieurs types de
données. Le tableau ci-après reprend les principaux types de données SQL et les méthodes en permettant

la lecture à partir d’un ResultSet . Les méthodes marquées avec le symbole sont les méthodes

conseillées. Les méthodes marquées avec le symbole sont possibles mais avec des risques de

perte d’informations.

Chacune de ces méthodes est disponible sous deux formes. La première accepte comme argument le
numéro de la colonne dont on souhaite obtenir la valeur. La numérotation commençant à 1. La deuxième
version accepte une chaîne de caractères représentant le nom de la colonne dans la base de données. Si
la requête ayant été utilisée pour créer le ResultSet contient des alias alors les colonnes portent le
nom de l’alias et non le nom du champ dans la base de données. Pour une meilleure lisibilité du code, il
est bien sûr préférable d’utiliser les noms des colonnes plutôt que leurs indices. Lorsque dans la base de
données un champ ne contient pas de valeur (NULL ), les méthodes retournent une valeur égale à 0 pour
les champs numériques, une valeur false pour les champs booléens et une valeur null pour les autres
types. Dans certains cas, il y a donc un doute possible sur la valeur réellement présente dans la base. Par
exemple, la méthode getInt peut retourner une valeur égale à zéro parce qu’il y a effectivement cette
valeur dans la

base de données ou parce que ce champ n’est pas renseigné dans la base de données.

Pour lever ce doute, la méthode wasNull retourne un boolean égal à true si le champ sur lequel la
dernière opération de lecture dans le ResultSet contenait effectivement une valeur null .

Le code suivant met en évidence la manipulation des types Java et SQL dans l’écriture et la lecture
d’informations. Un accent est mis sur la manipulation des dates.

Pour écrire une date dans une requête paramétrée, il est possible d’utiliser la méthode setDate qui
attend en deuxième paramètre un objet de type [Link] . Un objet de ce type ne doit pas être
manipulé dans le reste de l’application. Il est préférable d’utiliser un objet de type LocalDate (si la partie
horaire n’est pas utile) ou un objet de type LocalTime . La méthode [Link]
attend en paramètre un objet de type LocalDate pour obtenir un objet de type [Link] .

Pour écrire une date dans une requête paramétrée, il est aussi possible d’utiliser la méthode setObject
qui accepte en deuxième paramètre un objet. Cet objet peut être du type LocalDate . Le pilote JDBC
saura exploiter cet objet pour l’enregistrer dans une colonne de type Date .

Pour lire les données, les méthodes getXxx de l’interface ResultSet sont adaptées. La lecture d’une
date est réalisée avec la méthode getDate . Elle retourne un objet de type [Link] . Il est
possible d’obtenir un objet de type LocalDate à partir d’un objet de type [Link] grâce à la
méthode toLocalDate .

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];

public class TestMappingTypeJavaSQL {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
PreparedStatement pstm =
[Link]("insert into PERSONNES(nom, prenom, dateDeNaissance)
values(?,?,?)");
Statement stm = [Link]()) {
insererPersonnes(pstm);
lirePersonnes(stm);
} catch (SQLException e) {
[Link]();
}
}

private static void insererPersonnes(PreparedStatement pstm)

throws SQLException {
//L'instruction suivante permet de mettre en concordance
//la timezone de la JVM avec la timezone du serveur MySQL.
[Link]([Link]("UTC"));

//Ajout d'une première personne

//Appliquer les paramètres
[Link](1 , "Eastwood");
[Link](2 , "Clint");
//Ecriture de la date de naissance
//[Link](3, [Link](1930, 5, 31));
//ou
[Link](3 , [Link]([Link](1930, 5 , 31)));

//Exécuter la requête
int resultat = [Link]();
if(resultat==1 )
{
[Link]("L'insertion a réussi");
}

//Ajout d'une seconde personne

//Appliquer les paramètres
[Link](1 , "Tarantino");
[Link](2 , "Quentin");
[Link](3 , null);

//Exécuter la requête
resultat = [Link]();
if(resultat==1 )
{
[Link]("L'insertion a réussi");
}

private static void lirePersonnes(Statement stm) throws SQLException {

ResultSet rs = [Link]("select id, nom, prenom,
dateDeNaissance from PERSONNES");
[Link]("id\t\tnom\t\tprénom\t\
tdate de naissance");
while([Link]())
{
int id = [Link]("id");
[Link]([Link]()?"inconnu":id);
[Link]( "\t\t");

String nom = [Link]("nom");

[Link]([Link]()?"inconnu":nom);
[Link]( "\t\t");

String prenom = [Link]("prenom");

[Link]([Link]()?"inconnu":prenom);
[Link]( "\t\t");

Date sqlDate = [Link]("dateDeNaissance");

[Link]([Link]()?"inconnue":
[Link]("dd/MM/yyyy").format([Link]()));
}

private static Connection getConnexion() throws SQLException {

String url =
"jdbc:mysql://localhost/demo_java?ser verTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}
}

Le résultat de l’exécution de code est le suivant :

c. Modification des données dans un ResultSet

La modification des données est effectuée simplement en utilisant les méthodes updateXxx , où Xxx
correspond au type de données de la colonne à mettre à jour. Comme pour les méthodes getXxx , celles-
ci sont disponibles en deux versions, l’une attend comme argument l’indice de la colonne à mettre à jour,
la deuxième attend comme argument une chaîne de caractères représentant le nom de la colonne dans la
base de données. Si la requête ayant été utilisée pour créer le ResultSet contient des alias, alors les
colonnes portent le nom de l’alias et non le nom du champ dans la base de données. Pour une meilleure
lisibilité du code, il est bien sûr préférable d’utiliser les noms des colonnes plutôt que leurs indices.

Le type du deuxième argument attendu par ces méthodes correspond bien sûr au type de données à
mettre à jour dans le ResultSet . Les modifications doivent ensuite être validées par la méthode
updateRow ou annulées par la méthode cancelRowUpdates . Le ResultSet doit obligatoirement
être de type

CONCUR_UPDATABLE pour pouvoir être modifié. Dans le cas contraire, l’exécution d’une de ces
méthodes déclenche une exception.

L’exemple suivant met à jour le nom des personnes en utilisant un ResultSet . Bien entendu, dans un
contexte professionnel, il serait plus judicieux d’utiliser une instruction SQL pour réaliser cette tâche.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestModificationViaResultSet {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
Statement stmModif = [Link]
(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
Statement stmLecture = [Link]()) {
lireEtModifierPersonnes(stmModif);
lirePersonnes(stmLecture);
} catch (SQLException e) {
[Link]();
}
}

private static void lireEtModifierPersonnes(Statement stmModif)

throws SQLException {
ResultSet rs = [Link]("select id, nom,
prenom, dateDeNaissance from PERSONNES");
while([Link]())
{
//Modification du nom en le mettant en majuscules
[Link]("nom", [Link]("nom").
toUpperCase());

[Link]();
}
}

private static void lirePersonnes(Statement stm) throws SQLException {

String nom = [Link]("nom");

[Link]([Link]()?"inconnu":nom);
[Link]( "\t\t");

String prenom = [Link]("prenom");

[Link]([Link]()?"inconnu":prenom);
[Link]( "\t\t");

Date sqlDate = [Link]("dateDeNaissance");

[Link]([Link]()?"inconnue":
[Link]("dd/MM/yyyy").format([Link]()));
}

}
private static Connection getConnexion() throws SQLException {
String url = "jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}
}

L’exécution de ce programme donne le résultat suivant :

d. Suppression de données dans un ResultSet

La suppression d’une ligne est effectuée très simplement en positionnant le pointeur sur la ligne à
supprimer puis en appelant la méthode deleteRow . La ligne est immédiatement supprimée du
ResultSet et dans la base de données. La position du pointeur d’enregistrement après la suppression
dépend du pilote de base de données utilisé. Certains pilotes déplacent le pointeur sur l’enregistrement
suivant, d’autres le déplacent sur l’enregistrement précédent et enfin quelques-uns ne modifient pas la
position du pointeur. Il faut dans ce cas utiliser une des méthodes de déplacement pour positionner le
pointeur sur un enregistrement utilisable. Le ResultSet doit obligatoirement être de type
CONCUR_UPDATABLE pour pouvoir y supprimer des données. Dans le cas contraire, l’exécution de la
méthode deleteRow déclenche une exception.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestSuppressionViaResultSet {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
Statement stmSuppression =
[Link](ResultSet.TYPE_SCROLL_SENSITIVE,

ResultSet.CONCUR_UPDATABLE);
Statement stmLecture = [Link]()) {
lireEtSupprimerPersonnes(stmSuppression);
lirePersonnes(stmLecture);
} catch (SQLException e) {
[Link]();
}
}

private static void lireEtSupprimerPersonnes(Statement stmSuppression)

throws SQLException {
ResultSet rs = [Link]("select id, nom,
prenom, dateDeNaissance from PERSONNES");
while([Link]())
{
//Suppression de l'enregistrement si la personne
s'appelle Eastwood
[Link]("Personne courante :
" + [Link]("nom"));
if( "Eastwood".equalsIgnoreCase([Link]("nom")))
{
[Link]("Je supprime la personne");
[Link]();
}
}
}

private static void lirePersonnes(Statement stm) throws SQLException {

String nom = [Link]("nom");

[Link]([Link]()?"inconnu":nom);
[Link]( "\t\t");

String prenom = [Link]("prenom");

[Link]([Link]()?"inconnu":prenom);
[Link]( "\t\t");

Date sqlDate = [Link]("dateDeNaissance");

[Link]([Link]()?"inconnue":
[Link]("dd/MM/yyyy").format([Link]()));
}

}
private static Connection getConnexion() throws SQLException {
String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}
}

L’exécution de ce programme donne le résultat suivant :

Ce résultat permet de conclure que le pilote JDBC pour MySQL ne modifie pas la position du curseur après
la suppression d’un enregistrement.

e. Ajout de données dans un ResultSet

Chaque objet ResultSet contient une ligne spéciale destinée à l’insertion de données. Le pointeur
d’enregistrement doit au préalable être positionné sur cette ligne spéciale avec l’instruction
moveToInsertRow . Une fois que le pointeur est positionné sur cette ligne, celle-ci peut être mise à jour
avec les méthodes updateXXX . L’insertion de la ligne doit ensuite être validée avec la méthode
insertRow . Cette méthode provoque la mise à jour de la base de données. La ligne d’insertion devient à
ce moment une ligne normale du ResultSet et le pointeur d’enregistrement est positionné sur cette
ligne. Vous pouvez revenir sur la ligne sur laquelle vous étiez avant l’insertion grâce à la méthode
moveToCurrentRow . Si vous ne fournissez pas de valeur pour toutes les colonnes, des valeurs null
seront insérées dans la base de données pour les colonnes non renseignées. La base de données doit
accepter les valeurs nulles pour ces champs sinon une exception est déclenchée. Le ResultSet doit
obligatoirement être de type CONCUR_UPDATABLE pour pouvoir y insérer des données. Dans le cas
contraire, l’exécution de la méthode moveToInsertRow déclenche une exception.

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestInsertionViaResultSet {

public static void main(String[] args) {

try (Connection cnx = getConnexion();
Statement stmInsertion =
[Link](ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
Statement stmLecture =
[Link]()) {
ajouterPersonne(stmInsertion);

lirePersonnes(stmLecture);
} catch (SQLException e) {
[Link]();
}
}
private static void ajouterPersonne(Statement stmInsertion)
throws SQLException {
ResultSet rs = [Link]("select id, nom,
prenom, dateDeNaissance from PERSONNES");
[Link]();
[Link]("nom","DUJARDIN");
[Link]("prenom","Jean");
[Link]();
}

private static void lirePersonnes(Statement stm) throws SQLException {

String nom = [Link]("nom");

[Link]([Link]()?"inconnu":nom);
[Link]( "\t\t");

String prenom = [Link]("prenom");

[Link]([Link]()?"inconnu":prenom);
[Link]( "\t\t");
Date sqlDate = [Link]("dateDeNaissance");
[Link]([Link]()?"inconnue":
[Link]("dd/MM/yyyy").format([Link]()));
}

}
private static Connection getConnexion() throws SQLException {

String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}
}

L’exécution de ce programme donne le résultat suivant :

6. Gestion des transactions

Les transactions vont permettre de garantir qu’un ensemble d’instructions SQL sera exécuté avec succès.
En cas d’échec pour l’une d’entre elles, les instructions réalisées avec succès au préalable sont tout
simplement annulées. Ceci permet de maintenir cohérentes les informations présentes dans la base de
données. Le transfert d’une somme d’argent entre deux comptes bancaires représente l’exemple classique
où une transaction est nécessaire. Imaginez la situation suivante : notre banque doit effectuer
l’encaissement d’un chèque de 1000 € à débiter sur le compte numéro 12345 et à créditer sur le compte
67890. Par mesure de sécurité après chaque opération effectuée sur un compte (débit ou crédit), un
rapport est édité. Voici ci-dessous un extrait du code pouvant effectuer ces opérations.

public static void mouvement(String compteDebit,String compteCredit,

double somme)
{
try

Connection cnx=...

PreparedStatement stm;
stm=[Link]("update comptes set solde=solde
+ ? where numero=?");
[Link](1 ,somme * -1);
[Link](2 ,compteDebit);
[Link]();
impressionRapport(compteDebit, somme);
[Link](1 ,somme);
[Link](2 ,compteCredit);
[Link]();
impressionRapport(compteCredit, somme);
}
catch ( Exception e)
{
[Link]();
}
}

Pour 99,9999 % des mouvements effectués avec ce code, il n’y a aucun problème, mais un beau jour
l’imprimante chargée des éditions se bloque et ce blocage déclenche une exception dans la méthode
impressionRapport . A priori cette exception ne pose pas de problème puisque l’appel de cette
méthode est placé dans un bloc try et qu’un bloc catch traite l’exception. Il ne faut cependant pas
oublier que si une exception est déclenchée et qu’un bloc catch est exécuté, l’exécution se poursuit par
l’instruction suivant le bloc catch . Dans ce cas de figure, les instructions placées entre celle ayant
déclenché l’exception et la fin du bloc try ne sont tout simplement pas exécutées. Dans notre cas, ceci
peut être très problématique si cette exception est déclenchée dans la méthode impressionRapport
exécutée aussitôt après l’opération de débit. L’opération de crédit n’a tout simplement pas lieu. La somme
est donc perdue. Une solution consiste à annuler les instructions SQL ayant déjà été exécutées.

C’est ce mécanisme qui est mis en œuvre dans une transaction mais bien sûr de manière automatique.
C’est au niveau de la connexion vers le serveur de base de données que sont

gérées les transactions.

a. Mise en œuvre des transactions

Jusqu’à présent, nous ne nous sommes pas préoccupés des transactions et pourtant nous en réalisons
depuis notre première instruction SQL exécutée via JDBC. Le fonctionnement par défaut de l’API JDBC
consiste effectivement à inclure chaque instruction exécutée dans une transaction puis valider la
transaction si l’instruction a été exécutée correctement (commit ) ou à annuler l’instruction dans le cas
contraire (rollBack ). Ce mode de fonctionnement est appelé mode autoCommit . Si vous souhaitez
gérer vous-même la fin d’une transaction en validant ou en annulant toutes les instructions qu’elle
contient, vous devez désactiver le mode autoCommit en appelant la méthode
setAutoCommit(false) sur l’objet Connection . Vous êtes maintenant responsables de la fin des
transactions. Les méthodes commit et rollback de l’objet Connection permettent de valider ou
d’annuler les instructions exécutées depuis le début de la transaction. Une nouvelle transaction débute
automatiquement dès la fin de la précédente ou dès l’ouverture de la connexion. Le code permettant de
transférer un montant entre deux comptes doit donc prendre la forme suivante.

Pour que le programme suivant fonctionne, il est nécessaire de créer une table avec un jeu d’essai. Voici le
script de création de la table COMPTES et d’ajout de deux comptes :

create table COMPTES(

numero char( 9 ) primary key,
solde integer not null
);
insert into COMPTES(numero, solde) values( "123456789",2500);
insert into COMPTES(numero, solde) values( "987654321",10000);

À présent que la base de données est configurée, le code suivant permet de mettre en évidence le
fonctionnement des transactions :

package [Link];

import [Link];
import [Link];

public class TestTransaction {

public static void main(String[] args) {

mouvement("123456789", "987654321", 1000);
}

public static void mouvement(String compteDebit,

String compteCredit, double somme) {
try (Connection cnx = getConnexion()) {
try (PreparedStatement pstm =
[Link]("update COMPTES set solde=solde + ? where numero=?");) {
[Link](false);
[Link](1 , somme * -1);
[Link](2 , compteDebit);
[Link]();
impressionRapport(compteDebit, somme * -1);
[Link](1 , somme);
[Link](2 , compteCredit);
[Link]();
impressionRapport(compteCredit, somme);
//Validation des traitements
[Link]("Validation
de la transaction");
[Link]();
} catch ( Exception e) {
try {
//Annulation des traitements
[Link]("Annulation
de la transaction");
[Link]();
} catch (SQLException e1) {
[Link]();
}
[Link]();
}
} catch (SQLException e2) {
[Link]();

}
}

private static void impressionRapport(String compte, double somme)

throws Exception {
[Link](compte + " : " + somme);
//Décommentez la ligne suivante pour provoquer l'annulation
des traitements
//throw new Exception("Erreur édition du rapport");
}

private static Connection getConnexion() throws SQLException {

String url =
"jdbc:mysql://localhost/demo_java?serverTimezone=UTC";
String user = "mysqluser";
String password = "Pa$$w0rd";
return [Link](url, user, password);
}
}

Exécutez ce code en commentant ou décommentant la seconde instruction de la méthode

impressionRapport . Observez ensuite les données présentes dans la table pour comprendre le
mécanisme des transactions. En cas d’exception comme celle-ci :

les instructions SQL sont annulées et le contenu de la base de données n’est pas modifié.

b. Points de sauvegarde

Lors de l’appel de la méthode rollback , l’ensemble des instructions SQL exécutées depuis le début de
la transaction sont annulées. Cette méthode propose une deuxième version acceptant comme paramètre
un objet SavePoint . Cet objet représente un repère dans l’exécution des instructions SQL. Il est créé par
la méthode setSavePoint . L’appel de la méthode rollback avec comme argument un objet
SavePoint provoque

l’annulation de toutes les instructions exécutées jusqu’à ce point de sauvegarde.

c. Niveaux d’isolement

Pendant qu’une transaction est active, les données modifiées par les instructions exécutées au sein de la
transaction peuvent être verrouillées par la base de données pour éviter les conflits et les incohérences.
Différents types de verrous sont disponibles pour une transaction. Pour bien comprendre leurs effets, il
faut au préalable identifier les types de problèmes pouvant être rencontrés lorsqu’une transaction est
active.

ˇ Lecture erronée : cette anomalie se produit lorsqu’une application accède à des données qui
sont en train d’être modifiées par une transaction qui n’a pas encore été validée.
ˇ Lecture non reproductible : cette anomalie se produit lorsque les exécutions successives d’une
même instruction select ne produisent pas le même résultat. C’est le cas si les données que
vous lisez sont en cours de modification par une autre transaction.
ˇ Lecture fantôme : cette anomalie se produit si des exécutions successives d’une même
requête renvoient des données en plus ou en moins. Cela peut être le cas si une autre
transaction est en train de supprimer ou d’ajouter des données à la table.

L’API JDBC prévoit plusieurs niveaux d’isolement. Ils déterminent la manière dont sont verrouillées les
données durant la transaction. Ce verrouillage peut être placé en lecture, en écriture ou encore en lecture
et en écriture sur les données accédées par les instructions de la transaction.

La méthode setTransactionIsolationLevel permet de fixer les types de problèmes pouvant

être évités. Cette méthode accepte comme argument une des constantes présentées dans le tableau
suivant. Ce tableau présente également l’effet de chaque niveau d’isolement sur les données.

Lecture Lecture non Lecture

Constante
erronée reproductible fantôme

TRANSACTION_READ_UNCOMMITTED possible possible possible

TRANSACTION_READ_COMMITTED impossible possible possible

TRANSACTION_REPEATABLE_READ impossible impossible possible

TRANSACTION_SERIALIZABLE impossible impossible impossible

Le fait de spécifier un niveau d’isolement pour une transaction peut parfois avoir un effet sur les autres
applications accédant aux données manipulées dans la transaction puisque celles-ci peuvent être
verrouillées et donc être inaccessibles aux autres applications.

Vous aimerez peut-être aussi

Pilotes JDBC pour Oracle et MySQL
100% (1)
Pilotes JDBC pour Oracle et MySQL
112 pages
JDBC Oracle - Mysql
Pas encore d'évaluation
JDBC Oracle - Mysql
112 pages
Intégration de JDBC en Java
Pas encore d'évaluation
Intégration de JDBC en Java
15 pages
Introduction à JDBC et ses avantages
Pas encore d'évaluation
Introduction à JDBC et ses avantages
59 pages
Java - Connexion SGBD
Pas encore d'évaluation
Java - Connexion SGBD
13 pages
Introduction à JDBC et types de pilotes
Pas encore d'évaluation
Introduction à JDBC et types de pilotes
17 pages
JDBC et SQL Avancé en Java
Pas encore d'évaluation
JDBC et SQL Avancé en Java
17 pages
Introduction à JDBC pour bases de données
Pas encore d'évaluation
Introduction à JDBC pour bases de données
12 pages
Introduction à JDBC et ses drivers
Pas encore d'évaluation
Introduction à JDBC et ses drivers
20 pages
JDBC Oracle - Mysql
Pas encore d'évaluation
JDBC Oracle - Mysql
112 pages
Introduction à JDBC et ses pilotes
Pas encore d'évaluation
Introduction à JDBC et ses pilotes
11 pages
JDBC et UCanAccess en Java
Pas encore d'évaluation
JDBC et UCanAccess en Java
41 pages
Introduction à JDBC et ses Drivers
Pas encore d'évaluation
Introduction à JDBC et ses Drivers
22 pages
Accès JDBC aux Bases de Données
Pas encore d'évaluation
Accès JDBC aux Bases de Données
22 pages
Chapitre 2 JDBC
Pas encore d'évaluation
Chapitre 2 JDBC
21 pages
Accès aux bases de données avec JDBC
Pas encore d'évaluation
Accès aux bases de données avec JDBC
53 pages
Introduction à JDBC et Middleware Java
Pas encore d'évaluation
Introduction à JDBC et Middleware Java
17 pages
Accès aux bases de données avec JDBC
Pas encore d'évaluation
Accès aux bases de données avec JDBC
32 pages
Introduction à JDBC en JavaEE
Pas encore d'évaluation
Introduction à JDBC en JavaEE
34 pages
JDBC
Pas encore d'évaluation
JDBC
66 pages
Connexion JDBC à une base de données
Pas encore d'évaluation
Connexion JDBC à une base de données
20 pages
Connexion JDBC à MySQL sous Windows
Pas encore d'évaluation
Connexion JDBC à MySQL sous Windows
12 pages
Types de pilotes JDBC en Java
Pas encore d'évaluation
Types de pilotes JDBC en Java
2 pages
Accès aux bases de données en Java
Pas encore d'évaluation
Accès aux bases de données en Java
49 pages
JDBC : Accès aux bases de données en Java
Pas encore d'évaluation
JDBC : Accès aux bases de données en Java
14 pages
Connexion à une base de données en Java
Pas encore d'évaluation
Connexion à une base de données en Java
20 pages
Introduction au JDBC en Java
Pas encore d'évaluation
Introduction au JDBC en Java
10 pages
Interactions Java avec Bases de Données
Pas encore d'évaluation
Interactions Java avec Bases de Données
21 pages
JDBC : Connexion à une base de données
Pas encore d'évaluation
JDBC : Connexion à une base de données
27 pages
Connexion JDBC en Java
Pas encore d'évaluation
Connexion JDBC en Java
20 pages
Cours JDBC PDF
Pas encore d'évaluation
Cours JDBC PDF
13 pages
Introduction à JDBC pour Java et SQL
Pas encore d'évaluation
Introduction à JDBC pour Java et SQL
23 pages
Introduction à JDBC en Java
Pas encore d'évaluation
Introduction à JDBC en Java
15 pages
Accès aux bases de données en Java (JDBC)
Pas encore d'évaluation
Accès aux bases de données en Java (JDBC)
22 pages
Interactions JDBC avec les bases de données
Pas encore d'évaluation
Interactions JDBC avec les bases de données
13 pages
Connexion Java aux SGBD : JDBC et ODBC
Pas encore d'évaluation
Connexion Java aux SGBD : JDBC et ODBC
19 pages
Révision sur JDBC en Java
Pas encore d'évaluation
Révision sur JDBC en Java
4 pages
Introduction à JDBC et bases de données
Pas encore d'évaluation
Introduction à JDBC et bases de données
45 pages
Introduction à l'API JDBC en Java
Pas encore d'évaluation
Introduction à l'API JDBC en Java
16 pages
Introduction à JDBC par Bernard Espinasse
Pas encore d'évaluation
Introduction à JDBC par Bernard Espinasse
13 pages
Java JDBC
Pas encore d'évaluation
Java JDBC
20 pages
Connexion JDBC à une base de données
Pas encore d'évaluation
Connexion JDBC à une base de données
8 pages
Tutoriel JDBC pour MySQL en Java
Pas encore d'évaluation
Tutoriel JDBC pour MySQL en Java
2 pages
Introduction à JDBC en Java
Pas encore d'évaluation
Introduction à JDBC en Java
34 pages
Introduction à JDBC et accès aux bases de données
Pas encore d'évaluation
Introduction à JDBC et accès aux bases de données
28 pages
JDBC pour Java et Oracle : Guide Pratique
Pas encore d'évaluation
JDBC pour Java et Oracle : Guide Pratique
23 pages
Introduction à JDBC par Ed-drissiya
Pas encore d'évaluation
Introduction à JDBC par Ed-drissiya
31 pages
Introduction à JDBC en Java
Pas encore d'évaluation
Introduction à JDBC en Java
7 pages
Java et Bases de Données avec JDBC
Pas encore d'évaluation
Java et Bases de Données avec JDBC
22 pages
Installer MySQL JDBC sur Wildfly
Pas encore d'évaluation
Installer MySQL JDBC sur Wildfly
3 pages
Introduction à JDBC en Java
Pas encore d'évaluation
Introduction à JDBC en Java
41 pages
Connecter MySQL à NetBeans : Guide Complet
Pas encore d'évaluation
Connecter MySQL à NetBeans : Guide Complet
5 pages
ch6 java
Pas encore d'évaluation
ch6 java
16 pages
Introduction à JDBC en Spring Boot
Pas encore d'évaluation
Introduction à JDBC en Spring Boot
31 pages
Java BD
Pas encore d'évaluation
Java BD
25 pages
Introduction à JDBC pour Java
Pas encore d'évaluation
Introduction à JDBC pour Java
31 pages
Connexion Java à MS Access avec UCanAccess
Pas encore d'évaluation
Connexion Java à MS Access avec UCanAccess
6 pages
Accès aux bases de données avec JDBC
Pas encore d'évaluation
Accès aux bases de données avec JDBC
31 pages
JDBC : Connexion et requêtes SQL en Java
Pas encore d'évaluation
JDBC : Connexion et requêtes SQL en Java
17 pages
Examen Système d'exploitation 2025
Pas encore d'évaluation
Examen Système d'exploitation 2025
7 pages
TP Excel : Factures et Notes Étudiantes
Pas encore d'évaluation
TP Excel : Factures et Notes Étudiantes
3 pages
Devoir Mathématiques BTS : Circuit RC
Pas encore d'évaluation
Devoir Mathématiques BTS : Circuit RC
6 pages
Passer des arguments en Java avec Eclipse
Pas encore d'évaluation
Passer des arguments en Java avec Eclipse
3 pages
Exercice de mathématiques complexes et Fourier
Pas encore d'évaluation
Exercice de mathématiques complexes et Fourier
1 page
Exercices de mathématiques BTS sur fonctions complexes et séries de Fourier
Pas encore d'évaluation
Exercices de mathématiques BTS sur fonctions complexes et séries de Fourier
2 pages
Conception d'un site de don de sang en ligne
Pas encore d'évaluation
Conception d'un site de don de sang en ligne
53 pages
Refroidissement d'un solide : équation et solutions
Pas encore d'évaluation
Refroidissement d'un solide : équation et solutions
5 pages
Analyse des variations de la fonction tanh
Pas encore d'évaluation
Analyse des variations de la fonction tanh
1 page
Convention de Stage PFE 2018-2019
Pas encore d'évaluation
Convention de Stage PFE 2018-2019
2 pages
Calcul des pièces en traction simple
Pas encore d'évaluation
Calcul des pièces en traction simple
7 pages
Installation Office ProPlus 2024 Preview
Pas encore d'évaluation
Installation Office ProPlus 2024 Preview
3 pages
Importance des Zones Humides pour l'Humanité
Pas encore d'évaluation
Importance des Zones Humides pour l'Humanité
25 pages
Amplificateurs opérationnels : TD4 détaillé
Pas encore d'évaluation
Amplificateurs opérationnels : TD4 détaillé
2 pages
Création et Modification des Permissions SIAF
Pas encore d'évaluation
Création et Modification des Permissions SIAF
3 pages
Tableau de conversion de fractions
Pas encore d'évaluation
Tableau de conversion de fractions
1 page
Manuel d'utilisation moteur DEUTZ TCD 2012
Pas encore d'évaluation
Manuel d'utilisation moteur DEUTZ TCD 2012
84 pages
DELEUZE. Différence Et Répétition (Avant-Propos)
Pas encore d'évaluation
DELEUZE. Différence Et Répétition (Avant-Propos)
9 pages
Cours de Physique-Chimie 1ère A4 Togo
100% (2)
Cours de Physique-Chimie 1ère A4 Togo
42 pages
Caractéristiques et Calculs de Pompes
100% (1)
Caractéristiques et Calculs de Pompes
39 pages
Principes de justice selon John Rawls
Pas encore d'évaluation
Principes de justice selon John Rawls
4 pages
IA et Paris Sportifs en Afrique
Pas encore d'évaluation
IA et Paris Sportifs en Afrique
29 pages
Épreuve de Maths Bac 2014 - TSExp
Pas encore d'évaluation
Épreuve de Maths Bac 2014 - TSExp
2 pages
Analyse des groupements végétaux et écosystèmes
Pas encore d'évaluation
Analyse des groupements végétaux et écosystèmes
2 pages
Analyse Spectrale des Signaux Vocaux
Pas encore d'évaluation
Analyse Spectrale des Signaux Vocaux
5 pages
Institutions politiques de l'Égypte pharaonique
Pas encore d'évaluation
Institutions politiques de l'Égypte pharaonique
19 pages
Sensibilisation à la Pollution au Cap-Haïtien
Pas encore d'évaluation
Sensibilisation à la Pollution au Cap-Haïtien
3 pages
CV de Diarra Moussa, Comptable à Bamako
Pas encore d'évaluation
CV de Diarra Moussa, Comptable à Bamako
1 page
Montée d'air pour réservoir d'ammoniac
Pas encore d'évaluation
Montée d'air pour réservoir d'ammoniac
12 pages
Platon. Lectures Platoniciennes (Laurent Cournarie)
Pas encore d'évaluation
Platon. Lectures Platoniciennes (Laurent Cournarie)
179 pages
Brise-roche hydraulique HB 4100
Pas encore d'évaluation
Brise-roche hydraulique HB 4100
3 pages
Méthode des éléments finis en 1D
Pas encore d'évaluation
Méthode des éléments finis en 1D
25 pages
Recherche d'Information Efficace
Pas encore d'évaluation
Recherche d'Information Efficace
62 pages
Classification de l'affectivité et éthique médicale
Pas encore d'évaluation
Classification de l'affectivité et éthique médicale
3 pages
Propriétés physiques des sols
Pas encore d'évaluation
Propriétés physiques des sols
4 pages
Exercices sur la Notation Scientifique
Pas encore d'évaluation
Exercices sur la Notation Scientifique
7 pages
Diagnostic MFI/SFI : Codes et Procédures
Pas encore d'évaluation
Diagnostic MFI/SFI : Codes et Procédures
19 pages
Séííéê Dãäe H Äéäîéêäéöéíéåüåáâ
Pas encore d'évaluation
Séííéê Dãäe H Äéäîéêäéöéíéåüåáâ
20 pages
Manuel d'utilisation OLV-10 Concentrateur d'oxygène
Pas encore d'évaluation
Manuel d'utilisation OLV-10 Concentrateur d'oxygène
29 pages