Langage Java Accès aux Bases de Données

SOMMAIRE
1 Accès aux SGBDR via JDBC ........................................................................... 2
1.1. Connexion à la base par JDBC ................................................................... 3
1.1.1 JDBC et URL........................................................................................ 3
1.1.2 Les étapes de la connexion ................................................................... 3
1.2. Accès aux données de la base ..................................................................... 4
1.2.1 Déclaration de la zone de requête ......................................................... 4
1.2.2 Exécution de la requête......................................................................... 4
1.2.3 Exploitation des résultats ...................................................................... 5
1.2.4 Optimisation et paramétrage................................................................. 6
1.3. Appel aux procédure ou fonction stockées ................................................. 7
1.3.1 Création de l’objet CallableStatement ................................................... 7
1.3.2 Gestion des paramètres des procédures ou fonctions ........................... 8
1.3.3 Exécution de l’appel ............................................................................. 8
1.3.4 Gestion des erreurs ............................................................................... 8
1.3.5 Accès au dictionnaire de données......................................................... 9
1.4. Exemples de Programmes .......................................................................... 9
1.4.1 Création d’une table .............................................................................. 9
1.4.2 Insertion de tuples ............................................................................... 10
1.4.3 Sélection de tuples ............................................................................... 11
1.5. EXERCICE ............................................................................................... 13

Formateurs: ASSALE Adjé & KOUAME Appoh 1/13 INP-HB

Langage Java Accès aux Bases de Données

LANGAGE JAVA

1 Accès aux SGBDR via JDBC

JDBC (Java Data Base Connectivity) est une API (Application Programming
Interface) qui permet d’exécuter des ordres SQL dans un programme écrit en
langage Java. Cette API est constituée d’un ensemble de classes et d’Interfaces
qui font partie du JDK (Java Development Kit) et qui sont contenues dans le
package java.sql.

Interfaces Classes Exceptions

Array Date BatchUpdateException
Blob DriverManager DataTrucation
CallableStatement DriverPropertyInfo SQLException
Clob Time SQLWarning
DatabaseMetaData Timestamp
Driver Types
PreparedStatement
Ref
ResultSet
ResultSetMetaData
SQLData
SQLInput
SQLOutput
Statement
Struct

Interfaces – Classes et Exceptions de java.sql

Tout programme hôte écrit en Java et accédant à une base de données peut utiliser
JDBC, qu’il soit exécuté sur :
• Un poste client, sous forme d’application ou d’applet ;
• Un serveur Web, sous forme de servlet ou d’entreprise Javabeans ;
• Le serveur de la base de données, sous forme d’entreprise Javabeans ou
procédures stockées.

Formateurs: ASSALE Adjé & KOUAME Appoh 2/13 INP-HB

Langage Java Accès aux Bases de Données

1.1. Connexion à la base par JDBC

1.1.1 JDBC et URL

On se connecte au SGBDR en utilisant une URL (Uniform resource Location).

L’URL utilisé par JDBC est de la forme :
Jdbc :<subprotocol> :<subname>
• jdbc est le protocole
• <subprotocol> est le nom du driver utilisé, qui dépend du fournisseur :
on a oracle pour Oracle et mysql pour MySQL
• <subname> identifie la base de données sous forme d’une chaîne de
caractères. La structure de la chaîne dépend du driver utilisé. Pour
Oracle la structure est : <driver> :@<database> où :
- <driver> est le nom du driver (thin, oci7,oci8, etc.)
- <database> définit la chaîne de connexion à la base selon la
syntaxe : @<nom_ordinateur> :<port> :<SID>
Par exemple pour accéder à la base de données CFCIP qui se trouve sur
l’ordinateur NTserver ; on écrira l’URL de la manière suivante :
jdbc :oracle :thin :@ntserver :1521 :cfcip

Remarque : il est parfois simple d’utiliser un pont ODBC. Dans ce cas,

<subprotocol> est odbc et <subname> le nom DSN.

1.1.2 Les étapes de la connexion

- Déclaration du driver
Chaque base de données utilise un pilote (driver) qui lui est propre et qui permet
de convertir les requêtes JDBC dans le langage natif du SGBD. La déclaration du
driver doit s’effectuer au début de l’application, selon l’une des syntaxes suivantes
:
• Appel à la méthode registerDriver() du DriverManager :
DriverManager.registerDriver(new nom_de_driver())
exemple pour Oracle :
DriverManager.registerDriver(new oracle.jdbc.driver.oracleDriver())
• Appel à la méthode forName de la classe java.lang.Class
Class.forName("nom_du_driver") exemple pour
oracle :
Class i=Class.forName(‘’oracle.jdbc.driver.oracleDriver’’7) ;
des fois l’invocation explicite de la méthode newInstance() est
nécessaire : Class.forName(‘‘nom_du_driver’‘).newInstance()

Formateurs: ASSALE Adjé & KOUAME Appoh 3/13 INP-HB

Langage Java Accès aux Bases de Données

Remarque : dans le cas d’un pont JDBC-ODBC le constructeur SUN fournit le

driver suivant : ‘‘sun.jdbc.odbc.JdbcOdbcDriver’‘.

- Connexion
On réalise la connexion par appel de la méthode getConnection du
DriverManager, en suivant la syntaxe :
Connection nom_connexion = DriverManager.getConnexion(URL,
nom_utilisateur, mot_de_passe) ;
Exemple : Connection expl1 = DriverManager.getConnection
(‘‘jdbc :oracle :thin :@ntserver :1521 :cfcip’‘, ‘‘assale’‘, ‘‘louis ‘‘) ;

- Déconnexion
Concerne la libération des objets utilisés pour exécuter les requêtes
essentiellement les objets ResultSet et Statement, et la fermeture de la connexion.
nom_resultset.close()
nom_statement.close() nom_connexion.close()

1.2. Accès aux données de la base

L’accès nécessite 3 étapes :

• Déclaration de l’ordre à exécuter
• Exécution de l’ordre au niveau serveur
• Exploitation des résultats fournis par l’exécution dans le cas d’un ordre
SELECT

1.2.1 Déclaration de la zone de requête

On utilise un objet de type Statement qui offre non seulement une zone de
description (déclaration) de la requête SQL, mais aussi des ordres d’exécution de
la requête. La déclaration consiste alors à créer l’objet de type Statement ; la
syntaxe est :
Statement nom_statement = nom_connexion.createStatement() ;
Exemple :
Statement stmt = expl1.createStatement() ;

1.2.2 Exécution de la requête

Il faut distinguer les ordres de type SELECT des autres (CREATE, DROP,
INSERT, UPDATE, DELETE, GRANT, REVOKE, etc.).

Formateurs: ASSALE Adjé & KOUAME Appoh 4/13 INP-HB

Langage Java Accès aux Bases de Données

Pour les premiers on utilise la méthode executeQuery de l’objet Statement et qui

renvoie un objet de type ResultSet contenant les tuples du résultat.
Dans le second cas, on utilise la méthode executeUpdate qui renvoie un entier
(int) indiquant le nombre de lignes traitées.
Ces deux méthodes nécessitent un argument de type chaîne de caractères qui
indique la requête SQL à exécuter.

Les syntaxes respectives sont :

ResultSet nom_resultset = nom_statement.executeQuery(requête); int
nom_variable_resultset = nom_statement.executeUpdate(requête);

Dans le cas des ordres INSERT, UPDATE et DELETE les transactions

correspondantes sont gérées, par défaut en mode autocommit. On peut modifier
ce mode en faisant appel à la méthode setAutoCommit() qui admet un paramètre
de valeur true ou false.
Une fois le mode de gestion des transactions est rendu manuel, il faut utiliser les
méthodes commit() et rollback() pour respectivement valider ou annuler chaque
transaction.
Exemple :
nom_connexion.setAutoCommit(false) ;
nom_connexion.commit() ;

1.2.3 Exploitation des résultats

Pour les requêtes de type SELECT, l’objet ResultSet qu’on utilise est assimilable
à un curseur. Sa méthode next() distribue une à une les lignes résultats au
programme hôte. Pour exploiter l’ensemble des résultats, il faut utiliser une
structure répétitive du type : while (nom_resultset.next()) {…}
Pour recuperer les valeurs des colonnes de chaque ligne on utilise les méthodes
getXXX(col) où
• XXX dépend du type de la colonne résultat (voir tableau)
• Col représente une colonne de la requête exécutée et est soit le nom de
la colonne soit le rang dans l’ordre SQL

Formateurs: ASSALE Adjé & KOUAME Appoh 5/13 INP-HB

Langage Java Accès aux Bases de Données

Type SQL Type Java Fonction d’accès Java

CHAR String getString( )
VARCHAR String getString( )
NUMERIC Java.Math.BigDecimal getBigDecimal( )
DECIMAL Java.Math.BigDecimal getBigDecimal( )
BIT Boolean getBoolean( )
getInteger( )
INTEGER Integer
getFloat( )
REAL Float getDouble( )
DOUBLE Double Byte [] getByte( ) getDate(
BINARY java.sql.Date ) getTime( )
DATE java.sql.Time getTimestamp( )
TIME java.sql.Timestamp
TIMESTAMP

Exemple
while (curs1.next( ) ) {
String numero = curs1.getString (“Matricule”); String
nom = curs1.getString (“nom”)
…
}
Pour détecter les valeurs null des colonnes on utilise la méthode wasNull( ) du
ResultSet if (
curs1.wasNull ( ) )
{…}
1.2.4 Optimisation et paramétrage

Dans un programme le même ordre SQL peut être exécuté plusieurs fois, alors
que l’utilisation des méthodes createStatement() , executeQuery() et
executeUpdate() entraîne la compilation de l’ordre SQL à chaque appel. Pour
palier cela on utilise la méthode prepareStatement() qui pré-compile l’ordre
SQL et rend les exécutions plus rapides. Il est possible de paramétrer l’ordre
SQL, on parle alors d’ordre SQL dynamique.
L’exécution d’un ordre SQL se fait alors en 2 étapes
• Création de l’objet PreparedStatement
• Exécution de l’ordre

Formateurs: ASSALE Adjé & KOUAME Appoh 6/13 INP-HB

Langage Java Accès aux Bases de Données

Syntaxe de création de l’objet PreparedStatement est :

PreparedStatement nom_statement =
nom_connexion.prepareStatement(Ordre SQL) ;
On pose des paramètres fictifs dans la déclaration de l’ordre SQL en introduisant
un point d’interrogation ( ?) en lieu et place de la valeur de référence.
Le remplacement du paramètre fictif par la valeur correspondante au moment de
la demande d’exécution se fait par appel à la méthode setXXX() ou XXX
représente le type de la valeur à transmettre (String, int, etc.) . La syntaxe est :
nom_statement.setXXX(rang, valeur) où :
• Rang est la position du paramètre dans l’ordre SQL
• Valeur est la valeur à transmettre qui peut être soit une constante soit
une variable.
L’exécution de la requête s’effectue à l’aide de la méthode executeQuery() ou
executeUpdate()
Exemple
PreparedStatement stemp = nom_connexion.prepareStatement
(‘‘SELECT Matricule, Nom , Prénoms from. Etudiant Where nom = ?
and date_nais = ?’‘); stemp.setString(1,’‘koffi’‘)
stemp.setDate(2, Date.valueOf(‘‘1978-12-01’‘))
stemp.executeQuery( );

1.3. Appel aux procédure ou fonction stockées

On peut faire appel à une procédure ou fonction stockée dans la base de données
quelque soit le langage utilisé pour la décrire (PL/SQL/JAVA). Pour cela on
utilise l’objet Callablestatement sous 2 formes selon que la procédure possède ou
non des paramètres.
• Syntaxe pour appel à une procédure qui comporte des paramètres :
{ ? = call nom_procedure(?,?,…)} ou ? représente un paramètre fictif
• Syntaxe pour une procédure sans paramètre : {call nom_procedure}

1.3.1 Création de l‟objet CallableStatement

Elle se fait par appel à la methode prepareCall( ) selon la syntaxe :

Exemple
Appel à la procédure Ident_Etud(name out char, firstname out char, mat
Etudiant.Matricule%type) :

Formateurs: ASSALE Adjé & KOUAME Appoh 7/13 INP-HB

Langage Java Accès aux Bases de Données

CallableStatement stmc= nom_connexion.prepareCall(‘‘{call

ident_Etud( ?,?,?)}”);

1.3.2 Gestion des paramètres des procédures ou fonctions

Paramètre d’entrée
Au moment de l’exécution de la procédure, on remplace un paramètre fictif de
type IN ou INOUT par appel à la méthode setxxx où xxx représente le type de la
valeur à transmettre (String, int, etc.). La syntaxe est :
nom_statement.setxxx(rang, valeur) ;

Paramètre de sortie
Pour les paramètres de type OUT ou INOUT, il faut déclarer le type de chacun
d’eux avant l’exécution de l’appel. Cela se fait par appel à la méthode
registerOutParameter(rang, type). Le premier argument est la position du
paramètre dans la liste des paramètres de la procédure. Le second indique le type
du paramètre par référence à un élément de la classe java.sql.Types. La syntaxe
est :
nom_statement.registerOutParameter(rang, type) ;

1.3.3 Exécution de l‟appel

Elle s’effectue à l’aide de la méthode execute() selon la syntaxe :

nom_statement.execute() ;

Après exécution, il faut transférer les paramètres de type OUT ou INOUT à des
variables Java en utilisant la méthode getxxx().

Exemple :
stmc.registerOutParameter(1, Types.VARCHAR) ;
stmc.registerOutParameter(2, Types.VARCHAR) ;
stmc.setString(3, ‘‘12A’‘) ; stmc.execute() ; String
nom = stmc.getString(1) ; String prenom =
stmc.getString(2) ;

1.3.4 Gestion des erreurs

Pour utiliser l’API JDBC, il faut inclure le paquetage java.sql par import
java.sql.*. Comme pour toutes les entrées en Java, des exceptions sont générées
en cas d’erreur. Tous les ordres SQL doivent capter l’exception SQLException.

Formateurs: ASSALE Adjé & KOUAME Appoh 8/13 INP-HB

Langage Java Accès aux Bases de Données

Les méthodes de traitement d’erreurs relatives à cette exception sont :

getMessage() : renvoie une chaîne de caractères qui décrit l’erreur ;
• getErrorCode() : renvoie le code erreur ;
• getSQLState() : renvoie le statut de l’ordre SQL exécuté.

1.3.5 Accès au dictionnaire de données

Il est possible d’accéder aux informations du dictionnaire de données de la base

à laquelle le programme hôte est connecté grâce à la classe
java.sql.DatabaseMetaData. Cette classe contient plus d’une centaine de
méthodes qui permettent d’extraire des informations du dictionnaire de données.
On a par exemple :
• allTablesAreSelectable(), qui donne la liste des tables accessibles
par l’utilisateur courant ;
• getUserName(), qui donne la liste des utilisateurs enregistrés dans la
base ;
• getColumns(), qui donne la description des colonnes d’une table ;
• getURL(), qui donne l’URL de la base ;
• getColumnPrivileges(), qui donne les droits d’accès aux colonnes
d’une table.

Pour utiliser ces méthodes, il faut au préalable créer l’objet DatabaseMetaData

en utilisant la méthode getMetaData(), selon la syntaxe :
DatabaseMetaData nom_databasemetadat = nom_connexion.getMetaData()

Exemple
DatabaseMetaData dbmd = nomconnexion.getMetaData() ;
System.Out.println(‘‘\nConnecté à ‘‘ + dbmd.getURL()) ;
String utilisateurs = dbmd.getUserName() ;

1.4. Exemples de Programmes

Les exemples suivants utilisent comme URL un pont JDBC-ODBC, le nom de la

source de données DSN est exemple.

1.4.1 Création d‟une table

Cet exemple crée la table Clients dont la structure est :

CLIENTS(Nom varchar(10), Prenom varchar(10), Age int).

Formateurs: ASSALE Adjé & KOUAME Appoh 9/13 INP-HB

Langage Java Accès aux Bases de Données

import java.io.* ;
import java.sql.* ;

public class Creation

{
public static void main(String [] args)
{
String url = ″jdbc:odbc:exemple″
Connection con;
Statement stmt;
String requete;
requete = ″create table CLIENTS (Nom varchar(10),″+
″Prenom varchar(10), Age int)″;

try // enregistrement du driver

{
Class.forName(″sun.jdbc.odbc.JdbcOdbcDriver″);
}
catch(java.lang.ClassNotFoundException e)
{
System.err.print(″ClassNotFoundException: ″);
System.err.println(e.getMessage());
}

try // connexion et execution de la requete

{
con = DriverManager.getConnection(url, ″assale″, ″yvann″);
stmt = con.createStatement(); stmt.executeUpdate(requete);
stmt.close();
con.close();
}
catch(SQLException ex)
{
System.err.println(″SQLException: ″+ ex.getMessage());
}
}
}

1.4.2 Insertion de tuples

Formateurs: ASSALE Adjé & KOUAME Appoh 10/13 INP-HB

Langage Java Accès aux Bases de Données

import java.io.* ;
import java.sql.* ;

public class Insertion

{
public static void main(String [] args)
{
String url = ″jdbc:odbc:exemple″
Connection con;
Statement stmt;

try // enregistrement du driver

{
Class.forName(″sun.jdbc.odbc.JdbcOdbcDriver″);
}
catch(java.lang.ClassNotFoundException e)
{
System.err.print(″ClassNotFoundException: ″);
System.err.println(e.getMessage());
}

try // connexion et execution de la requete

{
con = DriverManager.getConnection(url, ″assale″, ″yvann″);
stmt = con.createStatement();
stmt.executeUpdate(″insert into CLIENTS Values″ +
″„Koffi‟, „Serge‟,30)″);
stmt.close();
con.close();
}
catch(SQLException ex)
{
System.err.println(″SQLException: ″+ ex.getMessage());
}
}
}

1.4.3 Sélection de tuples

import java.io.* ;

Formateurs: ASSALE Adjé & KOUAME Appoh 11/13 INP-HB

Langage Java Accès aux Bases de Données

import java.sql.* ;

public class Selection

{
public static void main(String [] args)
{
String url = ″jdbc:odbc:exemple″
Connection con;
Statement stmt;
String requete;
requete = ″select Nom, Prenom, Age from CLIENTS″;

try // enregistrement du driver

{
Class.forName(″sun.jdbc.odbc.JdbcOdbcDriver″);
}
catch(java.lang.ClassNotFoundException e)
{
System.err.print(″ClassNotFoundException: ″);
System.err.println(e.getMessage());
}

try // connexion et execution de la requete

{
con = DriverManager.getConnection(url, ″assale″, ″yvann″);
stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(requete);

System.out.println(″Liste des clients:″);

while(rs.next())
{
String n = rs.getString(1); // nom
String p = rs.getString(2); // prénom
int a = rs.getInt(3); // age
System.out.println(n + ″ ″ + p + ″ ″ + a);
}
stmt.close();
con.close();
}
catch(SQLException ex)

Formateurs: ASSALE Adjé & KOUAME Appoh 12/13 INP-HB

Langage Java Accès aux Bases de Données

{
System.err.println(″SQLException: ″+ ex.getMessage());
}
}
}

1.5. EXERCICE

Fiche de TD exercice 14

Formateurs: ASSALE Adjé & KOUAME Appoh 13/13 INP-HB