ROYAUME DU MAROC

Université Cadi Ayyad

Ecole Nationale des Sciences Appliqués
Département Génie Informatique, Réseaux & Télécoms
Safi
____________

JAVA II

oujaouram@yahoo.fr Mustapha OUJAOURA

Chap 05: JDBC (Java Data Base Connectivity)
• Introduction
• Architecture JDBC
• Principe et étapes d'accès à une BDD
• Résultat des requêtes avec ResultSet
• Types de données JDBC/SQL
• Accès aux méta-données
• Requêtes pré-compilées
• Les procédures stockées
• Les Transactions
• JNDI et BD dans le Web
 Introduction
3

¨ JDBC : est l'acronyme de Java Data Base Connectivity.

¤ Framework ou API permettant l'accès aux bases de données
relationnelles avec Java.
¨ Indépendamment du type de la base utilisée (MySQL,
Oracle, Postgres ...) Seule la phase de connexion au
SGBDR change.
¨ Permet de faire tout type de requêtes :
¤ Sélection de données dans des tables
¤ Création de tables et insertion d'éléments dans les tables

¤ Gestion des transactions

¨ Packages : java.sql et javax.sql.

 Introduction
4
¨ Pour pouvoir utiliser JDBC, il faut un pilote (Driver) qui est spécifique à la base de
données à laquelle on veut accéder.
¨ Ce pilote (Driver) permet de réaliser l'indépendance de JDBC vis à vis des bases de
données.
¨ Les drivers se présentent souvent sous forme de fichiers jar dont le chemin doit être
ajouté au classpath pour permettre au programme de l'utiliser.
¨ JDBC permet d’écrire des
applications Java qui gèrent
ces trois activités de
programmation:
¤ Se connecter à une source de
données, telle qu'une base de
données
¤ Envoyer des requêtes et
mettre à jour des instructions
dans la base de données
¤ Récupérer et traiter les
résultats reçus de la base de
données en réponse à votre
requête
 Architecture JDBC
5
¨ chaque SGBD utilise un pilote (driver) qui lui est propre et qui permet de convertir les
requêtes JDBC dans le langage natif du SGBD
¨ le driver est un ensemble de classes qui implantent les interfaces de JDBC
¨ les drivers sont le lien entre le programme Java et le SGBD
¨ ces drivers dits JDBC existent pour tous les principaux SGBD: Oracle, Sybase,
Informix, DB2, MySQL,…
¨ L'indépendance vis-à-vis de la plate-forme et
du format de base de données est assurée
par un gestionnaire de pilotes.
¨ Les classes de la bibliothèque JDBC sont en
effet largement dépendantes de
gestionnaires de pilotes, qui permettent de
savoir quels pilotes sont nécessaires pour
accéder aux enregistrements d'une base de
données. Chaque format de base de données
utilisé dans un programme nécessite un pilote
différent.
 Architecture JDBC
6

¨ JDBC est composé de deux parties:

¤ API JDBC, une API purement Java
¤ Gestionnaire de pilotes JDBC, qui
communique avec des pilotes spécifiques
au fournisseur qui effectuent la
communication réelle avec la base de
données.
¨ Ainsi, la traduction au format fournisseur
de la base de données est effectuée sur
le client:
¤ Aucun changement requis pour le serveur
¤ Pilote (traducteur) nécessaire sur le client
 Architecture JDBC
7

¨ L'API JDBC prend en charge les architectures à deux et à

trois tiers pour l'accès à la base de données.
¤ architecture 2/tiers :

¤ architecture 3/tiers :
 Principe d'accès à une BDD
8

¨ en utilisant JDBC, Les étapes à suivre pour accéder à une

base de données sont :
¤ 1. Charger ou Enregistrer le pilote (driver) JDBC
¤ 2. Établir la connexion au SGBD

¤ 3. Créer une requête (instruction SQL ou objet Statement)

¤ 4. Exécuter la requête

¤ 5. Traiter les résultats

¤ 6. Fermer la connexion
 Etape 1: Charger le pilote
9
¨ Cette étape permet de préciser le type de driver que l'on veut utiliser. Elle n’est plus requise
depuis Java 6 :
¤ Dans Java SE 6.0 et versions ultérieures (JDBC 4.0 et versions ultérieures), le pilote est chargé
automatiquement.
¨ Java 5 et versions antérieures :
¤ On charge la classe de pilote uniquement. La classe possède un bloc d'initialisation statique qui crée
une instance et l'enregistre auprès de DriverManager :
try {
//remplacé par: Class.forName("com.mysql.cj.jdbc.Driver");
Class.forName("com.mysql.jdbc.Driver");
Class.forName("oracle.jdbc.driver.OracleDriver");
}catch (ClassNotFoundException cnfe) {
System.out.println("Error loading driver: " + cnfe);
}

¨ Il ne faut pas oublier de mettre le jar du driver dans le CLASSPATH du projet :

¤ Cliquez avec le bouton droit de la souris sur le projet dans Eclipse, créez un nouveau dossier appelé
"lib". Mettez le jar dans lib.
¤ Cliquez sur le projet, choisir "Propriétés" puis "Java Build Path" et cliquez sur "Librairies" puis sur "Add
JARs".
¤ Accédez à "project/lib/" et sélectionnez le jar. Appuyer sur OK.
¤ Pour avoir le jar du driver MySQL, allez à : https://mvnrepository.com/artifact/mysql/mysql-
connector-java
 Etape 1: Charger le pilote
10
 Etape 2: Établir la connexion
11

¨ Cette étape permet de récupérer un objet « Connection » en s'identifiant

auprès du SGBD et en précisant la base utilisée.
¨ On utilise la méthode getConnection() de DriverManager :
¤ Connection connexion =DriverManager.getConnection(url, user, password);
n url : l’URL de la base de données, il contient le nom d'hôte, le port et le nom de la base
de données.
n user : le nom de l’utilisateur de la base
n password : le mot de passe de l’utilisateur de la base
Connection connexion=DriverManager.getConnection("jdbc:mysql://localhost/test", "root", "pass");

¨ DriverManager essaye tous les drivers enregistrés (chargés en mémoire avec

Class.forName()) jusqu’à ce qu’il trouve un driver qui lui fournisse une
connexion.
¨ Éventuellement, on peur rechercher des informations sur la base de données :
DatabaseMetaData dbMetaData = connexion.getMetaData();
String productName = dbMetaData.getDatabaseProductName();
System.out.println("Database: " + productName);
String productVersion = dbMetaData.getDatabaseProductVersion();
System.out.println("Version: " + productVersion);
 Etape 3: Créer une requête
12
¨ Cette étape permet de créé un Statement (instruction ou déclaration) qui correspond
à une requête, A partir de l’Objet Connection obtenu lors de l’étape précédente.
¨ Statement est un objet java utilisé pour envoyer des requêtes ou des commandes afin
d’interroger une base de données.
¨ L'interface Statement possède les méthodes nécessaires pour réaliser les requêtes sur
la base associée à la connexion dont il dépend
¨ On distingue 3 types de Statement :
¤ Statement : requêtes statiques simples
¤ PreparedStatement : requêtes dynamiques précompilées (avec paramètres d’entrée/sortie)
¤ CallableStatement : procédures stockées
¨ À partir de l’instance de l’objet Connection, on récupère le Statement associé :

Statement req1 = connexion.createStatement();

PreparedStatement req2 = connexion.prepareStatement(str);
CallableStatement req3 = connexion.prepareCall(str);
 Etape 4: Exécuter une requête
13
¨ Cette étape permet d’exécuter la requête liée à l’objet Statement crée dans l’étape
précédente au niveau du SGBD.
¨ On distingue 3 types d’exécution :
¤ consultation (requêtes de type SELECT)
n executeQuery() : retourne un ResultSet (n-uplets résultants)
¤ modification (requêtes de type INSERT, UPDATE, DELETE, CREATE TABLE, DROP TABLE)
n executeUpdate() : retourne un entier (nombre de n-uplets traités)
¤ nature inconnue, plusieurs résultats ou procédures stockées
n execute()
¨ executeQuery() et executeUpdate() de la classe Statement prennent comme argument une
chaîne (String) indiquant la requête SQL à exécuter :
st = connexion.createStatement();
ResultSet rs = st.executeQuery("SELECT nom, prenom FROM clients WHERE nom='maria' ORDER BY nom");
int nb = st.executeUpdate("INSERT INTO dept(DEPT) VALUES(54)");
¨ le code SQL n’est pas interprété par Java.
¤ c’est le pilote associé à la connexion (et au final le moteur de la base de données) qui interprète la
requête SQL
¤ si une requête ne peut s’exécuter ou qu’une erreur de syntaxe SQL a été détectée, l’exception
SQLException est levée
¨ le driver JDBC effectue d’abord un accès à la base pour découvrir les types des colonnes
impliquées dans la requête puis un 2ème pour l’exécuter.
 Etape 5: Traiter les résultats
14
¨ Cette étape permet de traiter les données retournées dans un objet de type ResultSet par les
requêtes de sélection (executeQuery("SELECT … FROM …")).
¨ executeQuery() renvoie une instance de ResultSet qui permet d’accéder aux champs des n-
uplets sélectionnés
¨ seules les données demandées sont transférées en mémoire par le driver JDBC, il faut donc les
lire "manuellement" et les stocker dans des variables pour un usage ultérieur.
¨ Méthodes importantes de ResultSet :
¤ resultSet.next () : Va à la rangée suivante. Retourne false s'il n'y a pas de ligne suivante.
¤ resultSet.getString ("nomcolonne") : Retourne la valeur de la colonne avec le nom désigné dans la
ligne actuelle, sous forme de chaîne. Aussi getInt, getDouble, getBlob, etc.
¤ resultSet.getString (columnIndex) : Retourne la valeur de la colonne désignée. Le premier index est 1
(pour SQL), pas 0 (pour Java).
¤ resultSet.beforeFirst () : Déplace le curseur avant la première ligne, comme auparavant. Aussi d'abord
¤ resultSet.absolute (rowNum) : Déplace le curseur sur la ligne donnée (en commençant par 1). Aussi
dernier et après le dernier.
ResultSet rsltSet = instruction.executeQuery("SELECT name, address FROM client");
while(rsltSet.next()) { //Using column names
System.out.printf("Name: %s, Adress: %s\n", rsltSet.getString("name"), rsltSet.getString("adress"));
}
while(rsltSet.next()) { //Using column indices
System.out.printf("Name: %s, Adress: %s\n", rsltSet.getString(1), rsltSet.getString(2));
}
 Etape 6: Fermer la connexion
15

¨ Cette étape permet de fermer la connexion avec la base de

données.
¨ Une fois terminé, il faut fermer la connexion à la base de données.
Toutefois, l'ouverture d'une nouvelle connexion coûte généralement
beaucoup plus cher que l'envoi de requêtes sur des connexions
existantes. Il faut donc reporter cette étape le plus longtemps
possible.
¨ Pour terminer proprement un traitement, il faut fermer les différents
espaces ouverts.
¤ sinon le ramasse-miettes s’en occupera mais moins efficace
¤ Chaque objet possède une méthode close() :
resultset.close();
statement.close();
connection.close();
 Résultat avec ResultSet
16
¨ Parcours itératif ligne par ligne : Méthode next()
¤ Retourne false si dernier n-uplet lu, true sinon
¤ Un appel fait avancer le curseur sur le n-uplet suivant. Au départ, le curseur est positionné
avant le premier n-uplet. Il faut exécuter next() au moins une fois pour avoir le premier :
while(rs.next()) { // Traitement de chaque n-uplet
}
¨ on peut parcourir le ResultSet dans le sens inverse: next() vs. previous()
¨ en déplacement absolu : aller à la n-ième ligne : absolute(int row), first(), last(), ...
¨ en déplacement relatif : aller à la n-ième ligne à partir de la position courante du
curseur, … : relative(int row), afterLast(), beforeFirst(), ...
¨ Les colonnes sont référencées par leur numéro (commencent à 1) ou par leur nom
¤ L’accès aux valeurs des colonnes se fait grâce à l’utilisation de méthodes de la forme
getXXX() pour faire la lecture du type de données Java XXX :
int val = rs.getInt(3) ; // accès au 3e attribut
String prod = rs.getString("PRODUIT"); // accès à la colonne "PRODUIT"
¤ Exemple :
Statement st = connexion.createStatement();
ResultSet rs = st.executeQuery("SELECT a, b, c, FROM Table1 ");
while(rs.next()) {
int i = rs.getInt("a");
String s = rs.getString("b");
byte[] b = rs.getBytes("c");
}
 Types de données JDBC/SQL
17

¨ Tous les SGBD n'ont pas les mêmes types SQL (même pour les
types de base, il peut y avoir des différences importantes)
¨ Le driver JDBC traduit le type JDBC retourné par le SGBD en
un type Java correspondant
¤ le XXX de getXXX() est le nom du type Java correspondant au
type JDBC attendu
¤ chaque driver a des correspondances entre les types SQL du SGBD
et les types JDBC
¤ le programmeur est responsable du choix de ces méthodes
n SQLException générée si mauvais choix
¨ Le tableau suivant montre l’équivalence de types entre Java et
SQL:
 Types de données JDBC/SQL
18

Type JDBC/SQL Méthode Java Type JDBC/SQL Méthode Java

CHAR, VARCHAR getString() REAL getFloat()
LONGVARCHAR getAsciiStream() DOUBLE, FLOAT getDouble()
NUMERIC, DECIMAL getBigDecimal() DATE getDate()
BINARY, VARBINARY getBytes() TIME getTime()
LONGVARBINARY getBinaryStream() TIME STAMP getTimeStamp()
BIT getBoolean() ARRAY getArray()
INTEGER getInt() BLOB getBlob()
BIGINT getLong() CLOB getClob ()
SMALLINT getShort() REF getRef ()
TINYINT getByte() AUTRE getObject()
 Types de données JDBC/SQL
19

¨ Pour repérer les valeurs NULL de la base :

¤ utiliser la méthode wasNull() de ResultSet
n renvoie true si l’on vient de lire un NULL, false sinon
¤ les méthodes getXXX() de ResultSet convertissent une valeur NULL
SQL en une valeur acceptable par le type d’objet demandé :
n les méthodes retournant un objet (getString(), getDate(),... ) retournent un
NULL Java
n les méthodes numériques (getByte() , getInt(),…) retournent "0"
n getBoolean() retourne "false"

¨ Exemple :
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("SELECT nom, commission FROM employe");
while (rs.next()) {
nom = rs.getString(1);
commission = rs.getDouble(2);
if (rs.wasNull()) System.out.println(nom + ": n'a pas de commission");
else System.out.println(nom + " a " + commission + "euros de commission");
}
 Accès aux méta-données
20
¨ JDBC permet de récupérer des informations
¤ sur le type de données que l'on vient de récupérer par un SELECT en utilisant l’interface
ResultSetMetaData.
¤ mais aussi sur la base elle-même en utilisant l’interface DatabaseMetaData.
¨ Interface ResultSetMetaData
¤ La méthode getMetaData() permet d’obtenir des informations sur les types de données du
ResultSet
¤ elle renvoie des instances de ResultSetMetaData
¤ on peut connaître entre autres :
n le nombre de colonne : getColumnCount()
n le nom d’une colonne : getColumnName(int col)
n le nom de la table : getTableName(int col)
n si un NULL SQL peut être stocké dans une colonne : isNullable()
Statement st = connexion.createStatement();
ResultSet rs = st.executeQuery("SELECT * FROM employe");
ResultSetMetaData rsmd = rs.getMetaData();
int nbColonnes = rsmd.getColumnCount();
for (int i = 1; i <= nbColonnes; i++) {
String typeColonne = rsmd.getColumnTypeName(i);
String nomColonne= rsmd.getColumnName(i);
System.out.println("Colonne " + i + " de nom "+ nomColonne +" de type "+ typeColonne);
}
 Accès aux méta-données
21

¨ Interface DatabaseMetaData
¤ informations sur la base de données
¤ méthode getMetaData() de l’objet Connection

¤ dépend du SGBD avec lequel on travaille

¤ elle renvoie des instances de DatabaseMetaData

¤ on peut connaître entre autres :

n les tables de la base : getTables()
n le nom de l’utilisateur : getUserName()
ArrayList<String> listTables= new ArrayList<String>();
String[] types = { "TABLE", "VIEW" };
DatabaseMetaData metaData = connexion.getMetaData();
ResultSet rs = metaData.getTables(null, null, "%", types);
while (rs.next()) {
String nomTable = rs.getString(3);
listTables.add(nomTable);
}
 Requêtes pré-compilées
22

¨ La plupart des SGBD offre la possibilité de n'analyser qu'une seule fois une
requête
¨ JDBC permet de bénéficier de cette fonctionnalité
¨ L’objet PreparedStatement envoie une requête sans paramètres à la base de
données pour précompilation et spécifiera le moment voulu la valeur des
paramètres
¤ plus rapide qu’un Statement classique
n le SGBD n’analyse qu’une seule fois la requête (recherche d’une stratégie d’exécution
adéquate)
n pour de nombreuses exécutions d’une même requête SQL avec des paramètres
variables
¤ tous les SGBD n’acceptent pas les requêtes précompilées
¨ Avantages des PreparedStatement
¤ Traitement plus rapide si utilisés plusieurs fois avec plusieurs paramètres
¤ Amélioration de la portabilité car les méthodes setXXX() n’ont pas à tenir compte
des différences entre SGBD
¤ Exemple: les SGBD n’utilisent pas tous les mêmes formats de date ('JJ/MM/AA' ou
'AAAA-MM-JJ') ou de chaînes de caractères (pour les caractères d'échappement)
 Requêtes pré-compilées
23

¨ Création d’une requête pré-compilée :

¤ La méthode prepareStatement() de l’objet Connection crée un objet de
type PreparedStatement :
PreparedStatement ps = connexion.prepareStatement("SELECT * FROM Clients WHERE name = ? ");

n les paramètres sont spécifiés par un "?"

n ils sont ensuite instanciés par les méthodes: setInt(), setString(), setDate()…
n ces méthodes nécessitent 2 arguments : setInt(n, valeur);
n le premier (int) indique le numéro relatif de l’argument dans la requête
n le second indique la valeur à positionner
n setNull(n, type) positionne le paramètre à NULL (null de SQL)
¨ Exécution d’une requête pré-compilée :
¤ Instancier les paramètres requis et invoquer ensuite l’une des méthodes
d’exécution executeQuery() ou executeUpdate() selon le type de requête:
PreparedStatement ps = connexion.prepareStatement("UPDATE employe SET sal = ? WHERE name = ?");
…
for(int i = 0; i < 10; i++) {
ps.setFloat(1, salary[i]);
ps.setString(2, name[i]);
int count = ps.executeUpdate();
}
 Les procédures stockées
24
¨ On rappel que les procédures stockées permettent de fournir la même fonctionnalité à plusieurs
utilisateurs. Elles permettent d'automatiser des actions qui peuvent être très complexes. Une procédure
stockée est en fait 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.
¨ pour l’usage des procédures stockées, JDBC offre une interface dédiée : CallableStatement
¤ dérive de l’interface PreparedStatement
¤ gère le retour de valeur avec ResultSet
¨ Comment :
¤ création d’un objet CallableStatement
¤ en utlisant Connection.prepareCall(…)
¨ Appel des procédures stockées
¤ La requête doit être formatée : encadrée par des accolades {…} , et utilisation du préfixe call
¤ Trois modes pour l'appel
n la procédure renvoie une valeur : { ? = call nomProcédure(?,?,…)}
n la procédure ne renvoie aucune valeur : { call nomProcédure(?,?,…)}
n si on ne lui passe aucun paramètre : { call nomProcédure }
¤ Passage de paramètres possible : comme pour PreparedStatement
¨ Exemple sans valeur de retour :
CallableStatement testCall = connexion.prepareCall("{ call setSalary(?,?) }");
testCall.setString(1, "€ EUR");
testCall.setLong(2, 2000);
testCall.execute();
 Les procédures stockées
25

¨ Accès aux résultats des procédures stockées :

¤ Un PreparedStatement peut retourner des données grâce à un ResultSet
¤ Les procédures stockées étendent le même modèle pour accéder aux résultats des
procédures stockées
n appel de la procédure précédé du passage des paramètres IN et OUT grâce aux
méthodes setXXX()
n type des paramètres OUT et INOUT grâce à la méthode registerOutParameter()
n exécution de la requête grâce à executeQuery(), executeUpdate() ou execute()
n récupération des paramètres OUT et INOUT grâce aux méthodes getXXX()
¨ Exemple en considérant la procédure stockée suivante :

CallableStatement csmt = connexion.prepareCall("{ call augmentation(?, ?, ?) }");

csmt.registerOutParameter(3, Types.DECIMAL, 2);// 2 chiffres après la virgule pour 3ème paramètre
csmt.setInt(1, 10); // Augmentation de 2,5 % des salaires du dept 10
csmt.setDouble(2, 2.5);
csmt.executeQuery();
double cout = csmt.getDouble(3);
System.out.println("Cout total de l'augmentation : " + cout);
 Les procédures stockées
26
¨ Les procédures stockées peuvent retourner n'importe quel type de données y compris des
ResultSet
¤ utiliser executeQuery() au lieu de execute()
¤ récupération d'un ResultSet normal
n utilisable comme d'habitude
n permet de sauvegarder la requête SQL au niveau de la base .
n Exemple :
CallableStatement csmt = connexion.prepareCall("{ call getDetails(?) }");
csmt.setLong(1, 1000000);
ResultSet rs = csmt.executeQuery();
¨ Une procédure stockée peut contenir plusieurs instructions SQL
¤ Pour accéder à tous les résultats de ces instructions, on utilise la méthode getMoreResults() de la classe
Statement
¤ Utilisation
n si une procédure contient 2 instructions SELECT
n execute()
n getResultSet()
n getMoreResult(), getResultSet()
n Si on ne connaît pas l'ordre des instructions SQL
n getMoreResults() renvoie true si le résultat est un ResultSet
n getUpdateCount() renvoie le nombre de n-uplets modifiés, ou -1 s'il n’y a plus de résultats (ou si le résultat est un ResultSet)
n Exemple de condition d'arrêt :
while (!csmt.getMoreResults() && csmt.getUpdateCount() == -1) {/* traitement */ }
 Les Transactions
27

¨ Par défaut : on a le mode auto-commit

¤ un "commit " est effectué automatiquement après chaque ordre SQL
¤ Par défaut, après chaque exécution d’une instruction SQL, les modifications sont
automatiquement validées dans la base de données.
¨ Pour gérer soi-même les transactions :
¤ Il faut alors désactiver la validation automatique pour regrouper deux instructions
SQL ou plus dans une transaction :
¤ connection.setAutoCommit (false);
¨ Ensuite, pour valider les transactions :
¤ appeler commit pour enregistrer de manière permanente les modifications
apportées à la base de données après l'exécution d'un groupe d'instructions.
¤ connection.commit();
¨ Si une erreur survient, pour annuler :
¤ On peut appeler rollback afin d’annuler les modifications apportées à la base de
données.
¤ connection.rollback();
 Les Transactions
28

¨ Exemple :
Connection connexion = DriverManager.getConnection("jdbc:mysql://localhost/test", "root", "password");
connexion.setAutoCommit(false);
try {
Statement statement = connexion.createStatement();
statement.executeUpdate("INSERT INTO etudiants (nom, age, note) VALUES ('Ahmed', '18', '14.25')");
statement.executeUpdate("UPDATE etudiants SET note = '12,5' WHERE (nom = 'Ali')");
...
connexion.commit();
} catch (Exception e) {
try {
connexion.rollback();
} catch (SQLException sqle) {
// report problème
}
} finally {
try {
connexion.close();
} catch (SQLException sqle) { }
}
 JNDI et BD dans le Web
29

¨ L’idée c’est d’utiliser un nom pour obtenir une connexion à partir

d'une source de données (objet DataSource du package
javax.sql.DataSource) au lieu de tout programmer.
¨ Avantage :
¤ Permet de changer la source de données sans changer de code.
¤ Disponible dans plusieurs applications Web pour les bases de données
réseau.
¨ Inconvénient :
¤ Nécessite l'enregistrement de la source de données spécifique auprès du
serveur d’applications web.
¨ Le Code pour les étapes 1et 2 vu précédemment est remplacé par:
Context context = new InitialContext();
DataSource dataSource = (DataSource)context.lookup("java:comp/env/jdbc/myDatabase");
Connection connection = dataSource.getConnection();
 JNDI et BD dans le Web
30
¨ Déclaration dans le fichier WEB-INF/Web.xml de l’application web :
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/myDatabase</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>

¨ Et dans le fichier META-INF/context.xml :

<Context>
<Resource
name="jdbc/myDatabase"
driverClassName="org.apache.derby.jdbc.ClientDriver"
url="jdbc:derby:myDatabase"
type="javax.sql.DataSource"
username="someuser"
password="somepassword"
auth="Container"
maxActive="8"
/>
</Context>
 Exemple
31
import java.sql.*;
public class ConnexionBD {
public Connection connexion;
public Statement instruction;
public ResultSet resultat, rs;
public ConnexionBD() {
try {
//Class.forName("com.mysql.jdbc.Driver").newInstance();
//Class.forName("com.mysql.jdbc.Driver"); //deprecated:remplacé par com.mysql.cj.jdbc.Driver
//Class.forName("com.mysql.cj.jdbc.Driver"); //plus besoin de charger le driver à partir de java 6
Connection connexion = DriverManager.getConnection("jdbc:mysql://localhost/test", "root", "pass");
instruction = connexion.createStatement();
//String url = "jdbc:mysql://localhost/test";
//String driver = "com.mysql.cj.jdbc.Driver";
//Class.forName(driver);
//Properties userInfo = new Properties();
//userInfo.put("user", "root");
//userInfo.put("password", "08111980");
//Connection connexion = DriverManager.getConnection(url, userInfo);
//instruction = connexion.createStatement();
} catch (Exception ex) {
System.err.println("Problème de pilote");
}
}
public void lire(String requete) {
try {
resultat = instruction.executeQuery(requete);
} catch (SQLException ex) {
System.err.println("Requète incorrecte "+requete);
}
}
 Exemple
32
public void miseAJour(String requete) {
try {
instruction.executeUpdate(requete);
} catch (SQLException ex) {
System.err.println("Requète incorrecte "+requete);
}
}
public boolean suivant() {
try {
return resultat.next();
} catch (SQLException ex) {
return false;
}
}
public void arret() {
try {
connexion.close();
} catch (SQLException ex) {
System.err.println("Erreur sur l'arrêt de la connexion à la base de données");
}
}
}
import java.sql.SQLException;
public class TestConnexionBD {
public static void main(String[] args) throws SQLException {
ConnexionBD con = new ConnexionBD();
con.lire("SELECT * FROM etudiants");
while (con.suivant()){
System.out.println("nom "+con.resultat.getString("nom")+" age "+con.resultat.getInt("age"));
}
}
}