I NTRODUCTIO N

1.A CCÉDER AUX BASES DE DONNÉES

On considère aujourd’hui qu’environ 80% des produits logiciels développés ont besoin
d’accéder à une base de données. Dès la conception du langage Java, l’accès aux bases de
données a donc été une priorité des concepteurs. L’API JDBC (Java Database Connectivity)
a été la première API développée après le JDK, et séparément de lui. Elle fut introduite dans
l'API standard dès le JDK 1.1. L’idée originale était de donner la possibilité à un
programme Java d’accéder à toute base de données ANSI SQL-2. Au début des années 90,
Microsoft avait écrit ODBC (Object Database Connectivity). La puissance commerciale de
cet éditeur avait imposé ce produit à toute l’industrie. ODBC est un jeu d’interfaces en C et
C++ permettant d’interroger une base de données d’un programme C ou C++. Tous les
fabricants de base de données ont donc développé des pilotes ODBC pour leur serveur. Le
pilote étant le composant logiciel reconnu par un code ODBC, et capable de dialoguer avec
une base de données spécifique. Les développeurs de Java ont donc eu la première idée de
développer JDBC au-dessus d’ODBC. Les premières versions de JDBC s’adressaient donc à
ODBC, ce qui a permis immédiatement à Java de pouvoir dialoguer avec à peu près tous les
serveurs de bases de données existants. Même si les performances n’étaient pas bonnes, le
pont JDBC-ODBC est un pilote qui s’adresse à un autre pilote, cette possibilité a
certainement contribué au succès rapide de Java. Aujourd’hui l’API JDBC est mature, et la
plupart des serveurs de bases de données ont leur pilote JDBC natif. On distingue plusieurs
types de pilotes JDBC, même si cette distinction est de moins en moins d’actualité, tant Java
est devenu incontournable pour les vendeurs de base de données.

Tableau 1. Types de pilotes JDBC

 Type de
pilote Description
JDBC

Pont JDBC-ODBC. La solution la moins coûteuse. Requiert du code natif

1
côté client. Solution peu performante.

API Java-native. La façon la plus simple pour le serveur de construire un

2
JDBC. Requiert du code natif côté client.

Pilote réseau tout en Java. Le type le plus flexible puisqu’il permet de se

3
connecter à une base de données en restant indépendant du middleware.

Pilote natif tout en Java. Le type le plus puissant. Nécessite de connaître le

4 protocole d’accès propre à la base de données. C’est ce type de pilote que les
vendeurs de base de données fournissent.

Voici la liste des différentes versions de JDBC, ainsi que le JDK correspondant.

Tableau 2. Versions successives de JDBC

Version de JDBC Version du JDK Packages

JDBC 1.0 (1998) JDK 1.1 java.sql

JDBC 2.0 (1999) JDK 1.2 java.sql

JDBC 2.0 options (1999) JDK 1.2 java.sql

JDBC 2.1 options (1999) JDK 1.2 java.sql

JDBC 3.0 API noyau (2001) JDK 1.4 java.sql, javax.sql

JDBC 4.0 (2006) JDK 6 java.sql, javax.sql

JDBC 4.1 (2011) JDK 7 langage, java.sql, javax.sql

Techniquement, JDBC est un ensemble d’interfaces qui définissent le schéma général de

connexion et d’interrogation des bases de données. Le pilote d’une base de données fournit
des classes qui implémentent ces interfaces. Il est donc propre à chaque base, mais on peut
l’utiliser de façon transparente en ne considérant que les interfaces. C’est même de cette
façon qu’il faut procéder.

2. P RINCIPE D ' ACCÈS À UNE BASE

Le principe d’utilisation du JDBC est particulièrement simple. Il se compose de quatre

actions :

 Chargement du pilote de la base.

 Ouverture d’une connexion à la base de données. Le code doit fournir au minimum
trois informations : une URL d’accès, un nom de connexion et un mot de passe.
 Création d’un objet de type Statement, qui va prendre en charge l’acheminement de
la requête SQL vers le serveur, et récupérer les résultats.
 Récupération du résultat de la requête dans un objet de type ResultSet, et
exploitation de ce résultat.

3. U N EXEMPLE SIMPLE

3.1. Chargement du pilote de la base

Le pilote d’une base de données est tout simplement une classe Java instance de
l’interface java.sql.Driver. Il est possible de charger une classe Java explicitement dans le
code, par appel de la méthode Class.forName(). Chaque éditeur de base de données fournit
une telle classe, généralement dans un JAR qui constitue le pilote complet. Le nom complet
de cette classe varie donc d'un éditeur à l'autre. Pour chaque base, il faut donc trouver ce
nom. Dans le cas de MySQL, il s'agit de com.mysql.jdbc.Driver. L'ouverture d'une
connexion sur une base MySQL aura donc la forme suivant :

 Tout d’abord chargement du pilote MySQL, récupération d’un objet de

type Class : Class.forName("com.mysql.jdbc.Driver") ;
  Invocation de la méthode newInstance() sur cet objet, qui nous retourne une instance
de ce driver, de type java.sql.Driver ;
 Enregistrement de ce pilote auprès du gestionnaire de pilotes JDBC de la machine
Java : DriverManager.registerDriver(pilote).

Ensuite ouverture de la connexion proprement dite :

Connection con = DriverManager.getConnection(chaineDeConnexion, user, password) ;

L’objet chaîneDeConnexion est de la classe String. C’est une concaténation des éléments
suivants :

 jdbc:mysql : indique le protocole utilisé pour accéder à la base de donnée. Ce

protocole est propre à chaque base.
 localhost:3306 : indique le nom d'hôte qui héberge la base de données, ainsi que le
port d'accès.
 nom_de_la_base : le nom de la base de données à laquelle on souhaite se connecter.

Ces différents éléments se concatènent en une chaîne unique qui a la forme

suivante : jdbc:mysql::3306/db_test Ces deux méthodes jettent bien sûr leurs propres
exceptions, notamment si la classe du pilote n’est pas trouvée, si une erreur s’est glissée
dans l’URL de connexion, si l’hôte est inaccessible, ou s’il se trouve une erreur dans les
identifiants de connexion.

3.2. Création d’une requête

Pour pouvoir passer une requête à la base, il faut un objet de type Statement. Cet objet
s’obtient en faisant appel à la méthode createStatement() de notre objet de type Connection.

Statement smt = con.createStatement() ;

On peut envoyer ensuite trois types de requêtes :

 Des sélections : smt.executeQuery(chaîneSQL) ;

 Des mises à jour : smt.executeUpdate(chaîneSQL) ;
 Des exécutions de procédures stockées : smt.execute(chaîneSQL).
3.3. Récupération d’un résultat

On récupère le résultat dans un objet de type ResultSet. Dans le cas d’une mise à jour de la
base, ce qui correspond aux commandes SQL insert, update, create, drop, delete, on utilise
la commande :

int i = smt.executeUpdate("insert into … values …") ;

L’entier de retour représente le nombre de lignes affectées dans le cas d’un insert,
d’un update ou d’un delete. Dans le cas d’une requête de sélection, un objet de
type ResultSet est renvoyé.

ResultSet resultSet = smt.executeQuery("select nom, age from Marins") ;

L’objet resultSet contient les lignes renvoyées par la requête. Enfin, pour parcourir ces
lignes, il faut utiliser les méthodes de l’interface ResultSet. Voici un exemple.

while (rs.next()) {

String nom = rs.getString("nom") ;

int age = rs.getInt("age") ;

Les champs des lignes sélectionnées sont maintenant disponibles sous forme d’objets Java,
ce qui était bien notre objectif. Nous reverrons toutes ces méthodes et cette procédure en
détails dans les paragraphes suivants.

3.4. Exemple complet

Voici un exemple complet du code que nous venons de présenter très rapidement.

Exemple 1. Un premier exemple de connexion - Mysql

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import com.mysql.cj.jdbc.Driver;
public class TestDB {

public static void main (String[] args) {

try {
// chargement de la classe par son nom
Class c = Class.forName("com.mysql.jdbc.Driver") ;
Driver pilote = (Driver)c.newInstance() ;
// enregistrement du pilote auprès du DriverManager
DriverManager.registerDriver(pilote);
// Protocole de connexion
String protocole = "jdbc:mysql:" ;
// Adresse IP de l’hôte de la base et port
String ip = "localhost" ; // dépend du contexte
String port = "3306" ; // port MySQL par défaut
// Nom de la base ;
String nomBase = "test_db" ; // dépend du contexte
// Chaîne de connexion
String conString = protocole + "//" + ip + ":" + port + "/" + nomBase ;
// Identifiants de connexion et mot de passe
String nomConnexion = "user" ; // dépend du contexte
String motDePasse = "passwd" ; // dépend du contexte
// Connexion
Connection con = DriverManager.getConnection(
conString, nomConnexion, motDePasse) ;

// Envoi d’un requête générique

String sql = "select * from Marins" ;
Statement smt = con.createStatement() ;
ResultSet rs = smt.executeQuery(sql) ;
while (rs.next()) {
System.out.println(rs.getString("nom")) ;
}
 } catch (Exception e) {
// gestion des exceptions
}
}
}

Exemple 2. Un premier exemple de connexion - POSTGRES

CREATE SEQUENCE seq_utilisateur INCREMENT 1 START 1;

CREATE TABLE utilisateur (

id integer NOT NULL DEFAULT nextval('seq_utilisateur'),

CONSTRAINT pk_utilisateur PRIMARY KEY (id)

);ALTER SEQUENCE seq_utilisateur OWNED BY utilisateur.id;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import org.postgresql.Driver;

public class TestDBd {

public static void main (String[] args) {
try {
// chargement de la classe par son nom
Class c = Class.forName("org.postgresql.Driver") ;
Driver pilote = (Driver)c.getDeclaredConstructor().newInstance() ;
// enregistrement du pilote auprès du DriverManager
DriverManager.registerDriver(pilote);
// Protocole de connexion
String protocole = "jdbc:postgresql:" ;
// Adresse IP de l’hôte de la base et port
String ip = "localhost" ; // dépend du contexte
String port = "5432" ; // port MySQL par défaut
 // Nom de la base ;
String nomBase = "is2m" ; // dépend du contexte
// Chaîne de connexion
String conString = protocole + "//" + ip + ":" + port + "/" +
nomBase ;
// Identifiants de connexion et mot de passe
String nomConnexion = "postgres" ; // dépend du contexte
String motDePasse = "" ; // dépend du contexte
// Connexion
Connection con = DriverManager.getConnection(
conString, nomConnexion, motDePasse) ;

// Envoi d’un requête générique

String sql = "select * from utilisateur" ;
Statement smt = con.createStatement() ;
ResultSet rs = smt.executeQuery(sql) ;
while (rs.next()) {
System.out.println(rs.getString("nom")) ;
}
} catch (Exception e) {
// gestion des exceptions
e.printStackTrace();
}
}
}

Eclipse – Utilisation de fichiers JAR

Dans un projet Java, il est souvent intéressant d'utiliser une bibliothèque externe en
plus de la bibliothèque standard Java. Généralement, une telle bibliothèque est
fournie sous la forme d'un fichier JAR (pour Java Archive) dont l'extension est .jar et
qui contient une collection de fichiers classe (.class).

Eclipse permet d'ajouter très facilement un tel fichier JAR à un projet, en suivant la
procédure ci-dessous :

1. Sélectionnez votre projet dans l'explorateur de paquetages (Package

Explorer).
2. Sélectionnez l'entrée Properties du menu Project.
3. Dans la boîte de dialogue qui s'ouvre, sélectionnez l'entrée Java Build Path.
4. Activez l'onglet Libraries et cliquez sur Add External JARs…. Dans la boîte de
dialogue qui s'ouvre, choisissez le fichier JAR que vous désirez utiliser, puis
cliquez sur Ok.