JDBC: Gestion des bases de données en Java

GESTION DES BASES DE DONNÉES EN JAVA
JDBC
Java DataBase Connectivity
parYouness BOUKOUCHI
ENSA-Agadir
4e année Génie Informatique

Définition
■ JDBC (Java DataBase Connectivity) est une bibliothèque d’interfaces et de classes
utilisées pour accéder à un SGBDR.
■ Un programme JDBC envoie à un SGBDR des requêtes écrites en SQL puis
exploite le résultat renvoyé en Java.
■ Chaque éditeur de SGBDR fournit son driver JDBC sous forme d’un ensemble de
classes rassemblées dans un fichier d’archive .jar , qu’il faut ajouter à l’option –
classpath lors de l’exécution de votre programme.
■ L'API JDBC est indépendante des SGBD. Un changement de SGBD ne doit pas
impacter le code applicatif
Prof y.boukouchi - ENSA d'Agadir 2

Les Drivers (Pilotes) JDBC
■ Le code applicatif est basé sur les interfaces du
JDBC. Au niveau du programme d’application on ne
travaille qu’avec les abstractions (interfaces)
sans ce soucier des classes effectives
d’implémentation
■ Les interfaces définissent une abstraction du pilote
(driver) de la base de données. Chaque fournisseur
propose sa propre implémentation de ces
interfaces
■ Pour accéder à un SGBD il est nécessaire de
disposer de classes implémentant ces interfaces.
L'ensemble de ces classes pour un SGBD donné est
appelé pilote (driver) JDBC
■ Drivers (ou pilotes) permettent de traduire les
requêtes JDBC dans le langage du SGBD, ils sont
constitués de classes implantant certaines
interfaces de java.sql.

types de pilotes JDBC
■ Type 1 (JDBC1): pont JDBC-ODBC
■ ‰Type 2 (JDBC2): driver qui fait
appel à des fonctions natives non
Java (le plus souvent en langage
C) de l'API du SGBD que l'on veut
utiliser
■ ‰Type 3 (JDBC3): driver qui
permet l'utilisation d'un serveur
middleware
■ ‰Type 4 (JDBC4): driver écrit
entièrement en Java, qui utilise le
protocole réseau du SGBD

Classes et Interfaces JDBC
■ L'API JDBC définit un
ensemble d'interfaces et
classes (package java.sql)
qui définissent un protocole
de communication entre le
programme java client et le
SGBD.
■ le package java.sql est
complété par le package
javax.sql
Les classes du package java.sql
Les interfaces du package java.sql

MISE EN ŒUVRE DE JDBC

Mise en œuvre de JDBC
■ Etape 0: Importer le package java.sql et le driver
■ Etape 1 Etablir la connexion au SGBD
■ Etape 2 Créer la requête (ou instruction SQL)
■ Etape 3 Exécuter la requête
■ Etape 4 Traiter les données retournées
■ Etape 5 Fermer la connexion

Exemple 1
package jdbc.tp.ensa;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
public class TP1Connexion {
private static String username="admin";
private static String password="admin";
private static String url="jdbc:mysql://localhost:3306/stock";
public static void main(String[] args) throws SQLException {
Connection conn=null;
try {
conn=DriverManager.getConnection(url, username, password);
System.out.println("Connexion etablie à la BD MySQL");
} catch (SQLException e) {
System.err.println("Problème de connexion à la BD ");
}finally {
if (conn!=null){conn.close();}
}
}
}
Les paramètres de connexion à la BD
Importer le package java.sql
Le DriverManager essaie tous les
drivers enregistrés jusqu'à ce
qu'il trouve un driver qui lui
fournisse une connexion.
Exception où cas d’une erreur
La fermeture de la connexion

Exemple 2
...
import java.sql.ResultSet;
import java.sql.Statement;
public class TP2Statement {
private static String username="admin";
...
public static void main(String[] args) throws SQLException {
Connection con=null; Statement stm=null; ResultSet rs=null;
try {
con=DriverManager.getConnection(url, username, password);
stm=con.createStatement();
String reqSQL="select * from produit";
rs=stm.executeQuery(reqSQL);
while(rs.next()){
System.out.println(rs.getInt(1)+":"+rs.getString("nom")+","+rs.getInt(3)+","+rs.getDouble("prix"));
}
} catch (SQLException e) {
System.err.println("Problème de connexion à la BD ");
}finally { if (rs!=null){rs.close();}
if (stm!=null){stm.close();}
if (con!=null){con.close();}
}
}
}
Création de la requête
Exécution de la requête
Parcours des résultats de ResultSet
Libération des ressources

Étape 1 : Etablir la connexion à la BD
■ On utilise la méthode getConnection() de DriverManager avec trois arguments :
– URL de la base de données de la forme : Protocole :<sous-protocole>:<nom-
BD>?param=valeur, ...
■ Protocole: JDBC
■ sous-protocole : mysql
■ exemples
– String url = "jdbc:odbc:maBase"
– String url = "jdbc:mysql://127.0.0.1:3306/maBase"
– String url = "jdbc:postgresql://localhost/maBase"
– User : le nom de l'utilisateur de la base
– Password : son mot de passe
■ Connection connexion = DriverManager.getConnection(url ,user , pw)
■ le DriverManager essaie tous les drivers enregistrés jusqu'à ce qu'il trouve un
driver qui lui fournisse une connexion.
■ La plupart des méthodes lèvent l'exception java.sql.SQLException.

Etape 2 : Créer une requête
■ La requête est créée avec l'interface Statement qui possède les méthodes
nécessaires pour réaliser les requêtes sur la base associée à la connexion
■ 3 types (interfaces) d'objets statement :
– Statement : requêtes simples (SQL statique)
– PreparedStatement : requêtes paramétrables (ou dynamiques) précompilées
(requêtes avec paramètres d'entrée/sortie)
– CallableStatement : encapsule procédures SQL stockées dans le SGBD
■ Création d'un statement :
– Statement stm = connexion.createStatement();
– PreparedStatement stm = connexion.prepareStatement(str);
– CallableStatement stm = connexion.prepareCall(str);

Etape 3 : Exécuter une requête
■ 3 méthodes d'exécutions d’un Statement:
– ResultSet executeQuery (String SQL) : pour les requêtes qui retournent un résultat
(SELECT) résultat accessible au travers d'un objet ResultSet
– int executeUpdate(String SQL) : pour les requêtes qui ne retournent pas de résultat
(INSERT, UPDATE, DELETE, CREATE TABLE et DROP TABLE)
– boolean execute(String SQL) : quand on ne sait pas si la requête retourne ou non un
résultat,procédures stockées.
■ Exécution de la requête :
– String myQuery = " SELECT prenom , nom , email FROM employe " ;
– ResultSet resultat = stm.executeQuery ( myQuery );
■ executeQuery renvoie un objet de type ResultSet décrivant la table des résultats

Etape 4 : traiter les données retournées
■ executeQuery() : renvoie une instance de ResultSet qui permet d'accéder aux
champs des n-uplets sélectionnés.
■ Les rangées du ResultSet se parcourent itérativement ligne (row) par ligne.
■ Exemple:
while(res.next()){ // Parcours du résultat
ref_produit=res.getString(1);
nom_produit=res.getString(2);
prix_produit=res.getDouble(3);
System.out.println(ref_produit+" : "+nom_produit+" : "+prix_produit);
}
– boolean next() : permet d'avancer à la ligne suivante, retourne false si pas de ligne
suivante placé avant la première ligne à la création du ResultSet
– Les colonnes sont référencées par leur numéro ou par leur nom
– L'accès aux valeurs des colonnes se fait par des méthodes (String nomCol) ou
getXXX(int numCol) où XXX dépend du type de la colonne dans la table SQL

Étapes 5 : fermer les connexions
■ Pour terminer proprement un traitement, il faut fermer les différents espaces ouverts. Le
ramasse-miettes peut le faire mais de façon moins efficace
■ Chaque objet possède une méthode close() :
– resultset.close ();
– statement.close ();
– connection.close ();

Traitement des exceptions JDBC
■ Les méthodes JDBC lancent une exception de type SQLException
■ SQLException étend la class Exception
■ Les methodes pour tracer les Exception:
– getMessage()
– getErrorCode()
– getLocalizedMessage()
– getSQLState()
– getNextException()
– setNextException()
– Iterator()

PARCOURS & ACTUALISATION DES DONNÉES

■ Les méthodes de ResultSet sont divisés en 3 catégories:
1. Méthodes de navigation (next(), first(), last(), etc.)
2. Méthodes de Getters (getInt(), getDouble(), getString(), etc.)
3. Méthodes de mise-à-jour (updateInt(), updateFloat(),
UpdateDate(), etc.)
ResultSet : Parcours & Actualisation des données

Parcours & Actualisation des données
■ Méthodes de navigation
Méthode (classe
ResultSet)
Fonction
next() Avance le curseur d’un enregistrement
previous() Recule le curseur d’un enregistrement
absolute(n) Place le curseur sur l’enregistrement de rang n s’il existe
relative(n) Déplace le curseur de n position (n peut être négatif) par rapport à sa
position actuelle
first() Place le curseur sur le premier enregistrement
last() Place le curseur sur le dernier enregistrement
beforFirst() Place le curseur avant le premier enregistrement
beforLast() Place le curseur avant le dernier enregistrement

■ Les méthodes d’information sur la position du curseur
Méthode (classe
ResultSet)
Fonction
isFirst() Fournit true si le curseur est placé sur le premier enregistrement
Islast() Fournit true si le curseur est placé sur le dernier enregistrement
isBeforFisrt() Fournit true si le curseur est placé avant le premier enregistrement
isBeforLast() Fournit true si le curseur est placé avant le dernier enregistrement
getRow() Fournit un entier correspondant au numéro de l’enregistrement désigné
par le curseur
■ Méthodes de navigation

■ les méthodes d’accès : les getters
■ Les correspondances entre type SQL et type Java sont données par les spécifications JDBC.
Type SQL Description Type Java Méthode java
BIT 1 bit Booblean getBoolean()
TINYINT Entier 8 bits Byte getByte()
SMALLINT Entier 16 bits Short getShort()
INTEGER Entier 32 bits Int getInt()
BIGINT Entier 64 bits Long getLong()
REAL Flottant 32 bits Float getFloat()
DOUBLE Flottant 64 bits Double getDouble()
DECIMAL(c,d) Nombre décimale de c chiffres dont d
décimale représenté de façon exacte
Java,math,BigDecimal getBigDecimal()
NUMERIC(c,d) Nombre décimale de c chiffres dont d
décimale représenté de façon exacte
Java,math,BigDecimal getBigDecimal()
CHAR(n) Chaine d’exactement n caractères String getString()
VARCHAR(n) Chaine d’au plus n caractères String getString()
DATE Date Java.SQL.Date getDate()
TIME Heure Java.SQL.Time getTime()
TIME STAMP Date et heure Java.SQL.Timestamp getTimeStamp()
BLOB Un BLOB ou Binary Large OBject permet de
stocker de grandes quantités de données
sous forme binaire.
java.sql.Blob getBlob()

■ Les méthode de mise-à-jour
■ La modification des résultats se fait a l'aide d’une méthode dont le nom est de la
forme :
– updateXXX( le champ concerné , la nouvelle valeur);
où XXX désigne un type Java.
■ Il faut réaliser plusieurs appels pour modifier plusieurs champs de l‘enregistrement
courant.
■ Enfin, il faut valider les modifications en appelant la méthode updateRaw(); si on ne
le fait pas avant déplacement du curseur, les modifications ne seront pas reportées
dans la base.
■ Exemple:
– res.updatelnt ("nom", "Pc portable");
– res.updateString ("quantité", 50);
– res.updateRow();

■ Les méthode de mise-à-jour
■ La suppression de l’enregistrement courant se fait en appelant la méthode
deleteRow().
■ L‘ajout d'un nouvel enregistrement se fait a l‘aide des méthodes moveTolnsertRow
et insertRow qu‘on utilise suivant ce schéma :
– rs. moveTolnsertRow(); // insère un nouvel enregistrement a la position du curseur.
– rs.updateXXX(..., ...); // utilisation des méthodes updateXXX
– rs.updateXXX(..., ...); //pour donner des valeurs aux différents champs
– ,,,,
– rs.insertRow() ; // l'insertion est reportée dans la base

■ On peut choisir différent mode de déplacement et différent modes d’actualisations des
données, en fournissant deux arguments à la méthode CreatStatement:
– CreateStatement( Type_défilement,Type_actualisation )
■ Type_défilement :
– ResultSet.TYPE_FORWARD_ONLY : curseur unidirectionnel (valeur par défaut)
– ResultSet.TYPE_SCROLL_INSENSITIVE : curseur bidirectionnel;modification de la base non
reportées dans les résultats
– ResultSet.TYPE_SCROLL_SENSITIVE: curseur bidirectionnel; modification de la base
reportées dans les résultats
■ Type_actualisation:
– ResultSet.CONCUR_READ_ONLY : les résultats ne peuvent pas être modifies pour mettre à
jour la base (valeur par défaut)
– ResultSet.CONCUR_UPDATABLE : les résultats sont modifiables et les modification sont
répercutées sur la base
■ Exemple :
– CreateStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)
– Équivaut à : CreateStatement()

■ Exemple
Statement stm = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rs=stm.executeQuery("SELECT Prenom, Nom, Num FROM Individu");
rs.moveToInsertRow();
rs.updateString(1, "Ali");
rs.updateString(2, "Fatima");
rs.updateLong(3, 2780);
rs.insertRow();
rs.moveToCurrentRow();

LES REQUÊTES PRÉPARÉES

Les requêtes préparées
■ Si on doit répéter plusieurs fois la même requête :
– SELECT * FROM produit WHERE reference=‘’A111’’
■ Alors requête préparée permet d‘écrire une seule requête dans laquelle on prévoit
un ou plusieurs paramètres, par exemple:
– SELECT * FROM produit WHERE reference=?
■ Le symbole ? désigne un paramètre dont la valeur sera fixée par la suite.
■ une requête préparée est transmise au SGDBR à l’aide de la méthode
prepareStatement de la classe Connection et elle est compilée partiellement.
■ On obtient en résultat un objet de type PreparedStatement contenant toutes les
informations nécessaires à l'exploitation de cette requête préparée par le SGDBR:
– String requeteSQL: = "Select * from produits WhERE reference = ?";
– PreparedStatement prepStmt = connec.prepareStatement(requeteSQL);

Les requêtes préparées
■ Ensuite, on peut transmettre au SGBDR, les valeurs voulues des paramètres, à
l'aide de méthodes de la forme setXXX (rang, valeur) de la classe
PreparedStatement, auxquelles on précise :
– le rang du paramètre concerné;
– la valeur prévue pour ce paramètre.
– exemple:prepStmy.setString(1, " A001 ");
■ En fin, on execute la requête par l’une de ces méthodes executeQuery,
executeUpdate ou execute.
– ResultSet res = prepStmt.executeQuery()
■ Exemple :
– String requeteSQL= " UPDATE produit set qte = ? Where reference=?";
– PreparedStatement prepStmt=con,prepareStatement(requeteSQL);
– prepStmt.setInt(1,12);
– prepStmt,setString(2," A001");
– ResultSet res = prepStmt.executeUpdate()

LES PROCÉDURES STOCKÉS

Procédure stocké
■ Une procédure stockée est une série d'instructions SQL désignée par
un nom.
■ Lorsque l'on crée une procédure stockée, on l'enregistre dans la base de
données que l'on utilise, au même titre qu'une table, par exemple.
■ Une fois la procédure créée, il est possible d'appeler celle-ci par son nom.
Les instructions de la procédure sont alors exécutées.
■ Contrairement aux requêtes préparées, qui ne sont gardées en mémoire
que pour la session courante, les procédures stockées sont stockées de
manière durable, et font bien partie intégrante de la base de
données dans laquelle elles sont enregistrées
CREATE PROCEDURE nom_procedure ([param1 [, param2, ...]])
corps de la procédure;

Procédure stocké
■ Exemples:
DELIMITER |
Begin
End|
-- Le délimiteur c'est le caractère qui permet de délimiter les instructions. Par défaut c’est ‘;’

DELIMITER | -- On change le délimiteur
CREATE PROCEDURE afficherProduits()
-- pas de paramètres
BEGIN
SELECT * FROM produit;
END| -- on termine la commande CREATE
PROCEDURE par le nouveau délimiteur
CALL afficherProduits();
Procédure stocké
Coté serveur Base des données
Coté application Java
Connection con=null;
CallableStatement cstm=null;
ResultSet rs=null;
try{
con=DriverManager.getConnection(url, username,
password);
String procedureSQL="call afficherProduits()";
cstm=con.prepareCall(procedureSQL);
cstm.execute();
rs=cstm.getResultSet();
String format="-%-6d%-30s%-10d%-15fn";
rs.beforeFirst();
while(rs.next()){
System.out.printf(format,rs.getInt("id"),
rs.getString("nom"), rs.getInt("quantite"),
rs.getDouble("prix"));
}
Procédure sans paramètres

Procédure stocké
Les types de Paramètres:
■ Le sens du paramètre peut prendre 3 valeurs :
• IN : le paramètre sera une valeur ou une variable d'entrée, envoyé lors de
l'appel, et qui sera utilisé à l'intérieur de la procédure.
• OUT : le paramètre sera une variable de sortie. Le paramètre indiqué sera
une variable (de session ou de procédure) qui prendra une valeur lors de
la procédure.
• INOUT : le paramètre sera une variable d'entrée-sortie. Cette variable
pourra être utilisé ou non dans la procédure, et verra normalement sa
valeur modifiée lors de la procédure.

CREATE PROCEDURE filterProduitQte(
IN qte int)
BEGIN
select *
from produit
where quantite>=qte;
end|
CALL filterProduitQte(10);
Procédure stocké
try{
password);
String procedureSQL="call filterProduitQte(?);";
System.out.print("Veuillez saisir la quantité
:");
int qteProduit=Integer.parseInt(scanner.nextLine());
cstm.setInt(1, qteProduit);
cstm.execute();
rs=cstm.getResultSet();
String format="-%-6d%-30s%-10d%-15fn";
rs.beforeFirst();
while(rs.next()){
System.out.printf(format,rs.getInt("id"),
rs.getString("nom"), rs.getInt("quantite"),
rs.getDouble("prix"));
}
Procédure avec un seul paramètre entrant

CREATE PROCEDURE valeurStock (
OUT pValeur double)
BEGIN
select sum(quantite*prix)
INTO pValeur
from produit;
end|
CALL valeurStock (@valeur);
Select @valeur;
Procédure stocké
Coté serveur Base des données Coté application Java
try{
password);
String procedureSQL="call valeurStock(?);";
cstm.registerOutParameter(1, Types.DOUBLE);
cstm.execute();
double valeur=cstm.getDouble(1);
System.out.println("La valeur de stock : "+
valeur);
Procédure avec un seul paramètre sortant

CREATE PROCEDURE valeurStockCumule
(IN pID int,INOUT pStockCumule float)
BEGIN
DECLARE valeur float;
SELECT sum(quantite*prix) INTO valeur
FROM produit
WHERE id=pID;
SET pStockCumule=pStockCumule+valeur;
end|
set @valeurStock=0;
select @valeurStock;
call valeurStockCumule(4,@valeurStock);
call valeurStockCumule(22,@valeurStock);
Procédure stocké
try{
password);
String procedureSQL="call valeurStockCumule(?,?);";
int idProduit=0;
float valeurStockCumule=0;
while(idProduit>=0){
System.out.print("Veuillez saisir ID Produit :");
idProduit=Integer.parseInt(scanner.nextLine());
cstm.setInt(1, idProduit);
cstm.setFloat(2,valeurStockCumule );
cstm.registerOutParameter(2, Types.FLOAT);
cstm.execute();
valeurStockCumule=cstm.getFloat(2);
System.out.println("La valeur de stock cumulé: "+
valeurStockCumule);
}
Procédure avec un seul paramètre Entrant/Sortant

LES TRANSACTIONS

Transaction
■ Par défaut la connexion est en « auto-commit » : un commit est
automatiquement lancé après chaque ordre SQL qui modifie la base ‰
■ Pour définir une transaction composée de plusieurs requêtes SQL, il faut
désactiver l'auto-commit : connect.setAutoCommit(false)
■ Il faut alors explicitement valider ou annuler la transaction par:
– connect.commit() : valide une transaction
– connect.rollback() : annule une transaction

Transaction
// Désactiver l'auto - commit
conn.setAutoCommit ( false );
try {
// les requêtes SQL suivantes constituent
// une seule transaction
st.executeUpdate (" INSERT ... ");
st.executeUpdate (" DELETE ... ");
st.executeUpdate (" UPDATE ... ");
// valider la transaction
con.commit ();
st. close ();
}
catch ( java.sql.SQLException e) { conn.rollback (); }

Batch :Traitement de masse
• JDBC permet de réaliser des mises à jour de masse en regroupant plusieurs traitements
pour les envoyer en une seule fois au SGBD.
• Ceci permet d'améliorer les performances surtout si le nombre de traitements est
important.
• Plusieurs méthodes ont été ajoutées à l'interface Statement pour pouvoir utiliser les mises
à jour de masse :
• void addBatch(String): permet d'ajouter une chaîne contenant une requête SQL
• int[] executeBatch(): permet d'exécuter toutes les requêtes. Elle renvoie un tableau
d'entiers qui contient pour chaque requête, le nombre de mises à jour effectuées.
• void clearBatch(): supprime toutes les requêtes stockées
• Lors de l'utilisation de batchupdate, il est préférable de positionner l'attribut
autocommit à false afin de faciliter la gestion des transactions et le traitement d'une
erreur dans l'exécution d'un ou plusieurs traitements.
connection.setAutoCommit(false);
Statement statement = connection.createStatement();
for(int i=0; i<10 ; i++) {
statement.addBatch("INSERT INTO personne VALUES('nom"+i+"','prenom"+i+"')");
}
statement.executeBatch();

LES METADATA

Les métadatas
■ JDBC permet d’offrir des données sur les données récupérées (Métadonnées) par la
connexion établée et les requetés exécutées.
■ Ces metadatas est très utiles pour savoir les capacités, les limitation et les
possibilité offertes par un système de gestion des bases de données et ainsi que ses
ressources.
■ JDBC support trois type de metaddata:
– Le metadata de la base des données
– Le metadata de ResultSet
– Le metadata des paramétres.

Les métadatas
■ Il existe deux sort de métadonnées:
1. Métadonnées associées à un objet résultat de type ResultSet, elles sont
encapsulées dans objet de type ResultSetMetaData qui dispose de méthodes
permettant d’obtenir des informations sur les champs qui constituent ce résultat à
l’aide de la méthode getMetadata():
■ ResultSetMetaData resMD= res.getMetaData();
■ resMD.getColumnCount(); //le nombre de colonne
■ resMD.getColumnName(int n); //le nom de la colonne de rang n
■ resMD.getColumnTypeName(i); // le type SQL du champ de rang i
■ resMD.getColumnClassName(i); // le type java à utilisé pour le champ de rang i
■ resMD.gettableName(i);// le nom de la table d’où est issu le champ de rang i
■ isNullable()
■ isAutoIncrement()
■ Etc.

2 - Métadonnées associées à la base. à partir d’une connexion établée on peut obtenir les métadonnées
relatives à cette base en créant un objet de type DatabaseMetadata à l’aide de la méthode getMetaData
de la classe Connection:
■ DatabaseMetadata resMDB= connect.getMetaData();
■ Informations sur le SGBD et Pilote:
– resMDB.getDriverName et resMDB.getDriverVersion
– resMDB.getSQLKeywords;// un tableau des mots-clés SQL reconnus par le SGBD
– resMDB.getTypeInfo(); // un ResultSet contenant la liste des types SQL accéptés par le SGBD
– resrMDB.getDatabaseProductName()
– resMDB.getDatabaseProductVersion()
– Etc.
■ Information sur la structure de la base:
– resMDB.getTable(catalogue, schéma, motif-séléction, type_tableaux);
String catalog=null, schemaPattern=null, tableNamePattern=null, types[]={"TABLE"};
ResultSet tables=metaDB.getTables(catalog, schemaPattern, tableNamePattern, types);
System.out.println(" ------ Tables-----");
while(tables.next()){
System.out.println(tables.getString("TABLE_NAME"));
}
Les métadatas

Merci de votre attention.

JDBC: Gestion des bases de données en Java

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à JDBC: Gestion des bases de données en Java

Similaire à JDBC: Gestion des bases de données en Java (20)

Plus de Youness Boukouchi

Plus de Youness Boukouchi (11)

JDBC: Gestion des bases de données en Java