Base de données API .

sql (JDBC)

Connexion à la base de données

Youness IDRISSI KHAMLICHI

Introduction
 l’API JDBC (Java DataBase Connectivity)
 L’API est un ensemble d’interfaces et de classes développée
par SUN pour permettre à des applications Java d’accéder à
des bases de données relationnelles quelconques (MySQL,
ORACLE, SYBASE, ODBC, Derby).
 JDBC est une API du niveau SQL, elle permet d’exécuter des
instructions SQL et de retrouver les résultats (s’il y en a)
 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

2
Se connecter aux bases de données

B.D.R

Application
JAVA ?

L’API JDBC est pour exécuter, depuis un programme Java,

l'ensemble des ordres SQL reconnus par la base de données cible.

3
Se connecter aux bases de données

B.D.R

API JDBC
Application
JAVA ?

L’API JDBC permet d'exécuter des instructions SQL.

JDBC fait partie du JDK (Java Development Kit) :

Package java.sql
import java.sql.*;

4
Se connecter aux bases de données

B.D.R

Driver Manager
API JDBC
Application
JAVA ?

Le pilote...
établit le lien avec la base de données.
Dans JDBC : des classes chargées de gérer un
pilote...

Des pilotes existent pour MySQL, Oracle,

PostGresSQL, ACCESS,...

5
Se connecter aux bases de données

B.D.R

Driver Manager

Natif Library
API JDBC

JDBC Driver
Application Appels SQL
JAVA

La connexion...
Elle peut s‘établir SI on donne l'adresse de la BD à laquelle se connecter...

6
Se connecter aux bases de données
 Préparatifs :
 D’abord installer un driver JDBC, à titre d’exemple :
 MySQL : MySQL Connector :
https://dev.mysql.com/downloads/connector/j/
 SQL Server de Microsoft :
https://docs.microsoft.com/fr-fr/sql/sql-server/sql-server-technical-
documentation
 Oracle 11g :
http://www.oracle.com/technetwork/apps-tech/jdbc-112010-090769.html

7
Se connecter aux bases de données
 JDBC en quatre étapes
1. Charger le pilote
2. Se connecter à la base
3. Créer et exécuter une requête SQL
4. Traiter le résultat si nécessaire

8
Interface de JDBC
C
DriverManager

getConnection()
I I I Canal de
Connection Connection Connection communication TCP
vers une BD

createStatement()

I Prepared
I Prepared
I Callable
I
Statement Gère les requêtes SQL
Statement Statement Statement

executeQuery(stmt) executeUpdate(stmt)

I I I gère l’accès aux tuples

ResultSet ResultSet ResultSet d’un résultat

9
Étape 1 : Charger un pilote (Driver)
 Le pilote est obligatoire, il convertit les appels JDBC en
appels natifs. Il est nécessaire de connaître le nom de la
classe du pilote JDBC que l’on veut utiliser
 Pilote ORACLE : oracle.JDBC.driver.OracleDriver
 Pilote JDBC/ODBC : sun.jdbc.odbc.JdbcOdbcDriver
 Pilote MySQL : com.mysql.jdbc.Driver
 Pilote Derby : org.apache.derby.jdbc.ClientDriver
 Le chargement du pilote se fait en utilisant la méthode
forName de la classe Class :
Class.forName(String Pilote) throws ClassNotFoundException

Chargement du
Class.forName("com.mysql.jdbc.Driver");
pilote MySQL
10
 Étape 2 : se connecter à la base (1/3)
 Pour se connecter à une base de données il faut fournir une
URL qui indique où se trouve la base
 URL ORACLE : jdbc:oracle:thin:host:port:idbase
 URL ODBC : jdbc:odbc:IDDSN
 URL mySQL : jdbc:mysql:host
 URL Derby : jdbc:derby:host
 Et préciser :
 Le nom de la machine (ou son numéro IP)
 Le port où le service de la B.D est démarré
 Le nom de la base de données
 Le login utilisé ainsi le mot de passe
 La connexion à la base se fait en utilisant la méthode
DriverManager.getConnection("URL","user","pass") throws SQLException
Connexion à une base
ORACLE nomée ORCL
Connection ma_connexion =
DriverManager.getConnection("jdbc:oracle:thin:@dbhost:1528:ORCL","login","pass");
11
Étape 2 : se connecter à la base (2/3)
 Le JDBC Thin driver : c’est le driver par excellence. Il est
de type 2, donc entièrement écrit en java. Pas besoin
d’autres installation de logiciel oracle pour son
fonctionnement. Il utilise le Oracle Net Services pour
communiquer avec la base de données.
 Oracle Net Services = ensemble de programmes
permettant aux applications clientes de communiquer avec
la base de données.

 L’URL de connexion à Oracle incluant le type de driver

est :
url="jdbc:oracle:thin:@IP:PORT:ServiceName";
12
Étape 2 : se connecter à la base (3/3)
public void init(ServletConfig config) throws ServletException {
try {
Class.forName("com.mysql.jdbc.Driver"); Charger le pilote
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost/ensaf",
"root", "");
//… Établir la connexion
conn.close();
} catch (ClassNotFoundException e) { opérations
System.err.println("Driver non chargé");
e.printStackTrace();
} catch (SQLException e) {
message = "Error. *" + e.toString();
} catch (Exception e) {
message = "Error. " + e.toString();
}
} Établir la connexion avec MySQL
DriverManager: sa méthode statique getConnection va créer
13 un objet de connexion de la classe Connection.
Étape 3 : Créer et exécuter une requête SQL
 L’exécution d’une requête SQL passe par l’utilisation
d’une classe, spécifique au pilote utilisé, implémentant
l’interface Statement

 Un objet de type Statement se doit d’être adapté à la

base manipulée. JDBC ne fournit que l’interface
Statement, qui est implantée par différentes classes du
pilote chargé

 Obtenir un objet Statement : avec la méthode

createStatement
Étape 3 : Créer et exécuter une requête SQL
 La requête ne peut être créée et exécutée que si le pilote
et la connexion à la base se sont valides
 Il faut avant tout créer une instruction SQL sur la base
createStatement() throws SQLException
Statement monStatement = maConnexion.createStatement();
La référence de la connexion
à une base de données
 Il faut enfin exécuter la requête en écrivant concrètement la
requête SQL executeQuery(String requete) throws SQLException

ResultSet monResultat = monStatement.executeQuery("SELECT * FROM `table`");

Référence de l’instruction SQL

Exécuter la requête
15 et stocker le résultat
Étape 3 : Créer et exécuter une requête SQL
 La méthode excuteQuery est utilisée pour la requête
(SELECT)
 Exemple :
ResultSet monResultat =
monStatement.executeQuery("SELECT * FROM `table`");
À noter :
`table` : dans le cas de MySQL
table sans guillemets dans le cas d’Oracle
 La méthode ExecuteUpdate est utilisée pour les
requêtes DML (INSERT, DELETE, UPDATE)
 Exemple :
int monResultat =
monStatement.executeUpdate("INSERT into `table` ….");
16
Étape 3 : Créer et exécuter une requête SQL
 L’interface ResultSet représente une table de lignes et de
colonnes.
 Une ligne représente un enregistrement
 Une colonne représente un champ particulier de la table
 Un objet de type ResultSet possède un pointeur sur
l’enregistrement courant.
 À la réception de cet objet, le pointeur se trouve devant
le premier enregistrement.
 On y accède ligne par ligne, puis colonne par colonne
dans la ligne.

17
Étape 4 : Traiter le résultat
 Pour pouvoir récupérer les données contenues dans l’instance de
ResultSet, celui-ci met à disposition des méthodes permettant de :
 Positionner le curseur sur l’enregistrement suivant :
 public boolean next(); Renvoi un booléen indiquant la présence
d’un élément suivant.
 Accéder à la valeur d’un champ (par indice ou par nom) de
l’enregistrement actuellement pointé par le curseur avec les
méthodes getString(), getInt(), getDate() …..
 public String getString(int indiceCol);
 public String getString(String nomCol);

18
Étape 4 : Traiter le résultat
 Enfin il faut traiter un objet de type ResultSet il existe de
nombreuses méthodes
 boolean next() : avancer d’une ligne de la table résultante
 String getString(String columName) : interroger un champ String par son
nom
 String getString(int columnIndex) : interroger un champ String par son
index
 int getInt(…) : interroger un champ Integer par son nom ou index
 … Accède à la prochaine
ligne
s’il y en a
while (monResultat.next()) {
String colonne1 = monResultat.getString(1);
out.println("Nom:" + colonne1);
}
monResultat.getString("nom");
Afficher le résultat en monResultat.getInt("age");
19
ligne
 Se connecter aux bases de données :
Exemple avec MySQL:
1 3

2 5

8 9

20
Se connecter aux bases de données :
Exemple avec MySQL: (Select) (1/3)
 Résultat :

 Chargement de packages :
package database;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

21
Se connecter aux bases de données :
Exemple avec MySQL: (Select) (2/3)
 Se connecter à une base de données et exécuter une
requête SQL :
public class Connexion {
public static void main(String[] args) {
try {
//1- Charger le pilote
Class.forName("com.mysql.jdbc.Driver");
System.out.println("Driver loaded ...");
//2- Se connecter à la base de données
Connection connection =
DriverManager.getConnection("jdbc:mysql://localhost/ensaf",
"root", "");
System.out.println("Connection established ...");
//3- Préparer, créer et exécuter une requête SQL
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("select * from
`client`");
22
Se connecter aux bases de données :
Exemple avec MySQL: (Select) (3/3)
 Cas d’afficher les données avec la commande SELECT :
//4- Traiter le résultat
while(resultSet.next()) {
String Nom = resultSet.getString("nom");
String Prenom = resultSet.getString("prenom");
System.out.println("La liste des clients enregistrée dans la
base de données : ");
System.out.println(Nom + " " + Prenom);
}

} catch (ClassNotFoundException e) {
System.out.println("Driver not loaded!");
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}}}

23
Se connecter aux bases de données :
Exemple avec MySQL: (INSERT)
 Dans cette partie d’insertion, nous avons crée deux types
de méthode, la première avec une requête simple et la
deuxième contient une requête complexe
 Méthode inserer()
 Méthode inserer(Arguments)

24
Se connecter aux bases de données :
Exemple avec MySQL: (INSERT) (1/5)
 Résultat :

 Chargement de packages :
package database;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Connexion {
private static Connection connection;
private static ResultSet resultSetSelect;
private static int resultSetInsert;
private static Statement statement;
25
 Se connecter aux bases de données :
Exemple avec MySQL: (INSERT) (2/5)
 Méthode de chargement de la base et connexion :
public static void charger() {
try {
//1- Charger le pilote
Class.forName("com.mysql.jdbc.Driver");
System.out.println("Driver loaded ...");
//2- Se connecter à la base de données
connection =
DriverManager.getConnection("jdbc:mysql://localhost/ensaf",
"root", "");
System.out.println("Connection established ...");
} catch (ClassNotFoundException e) {
System.out.println("Driver not loaded!");
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
26
Se connecter aux bases de données :
Exemple avec MySQL: (INSERT) (3/5)
 Méthode d’insertion d’un enregistrement :
public static void inserer(){
try {
//3- Préparer, créer et exécuter une requête SQL
statement = connection.createStatement();
resultSetInsert = statement.executeUpdate("insert into
`client`(`nom`, `prenom`) values('Alami', 'Driss');");
} catch (SQLException e) {
e.printStackTrace();
}
}

27
Se connecter aux bases de données :
Exemple avec MySQL: (INSERT) (4/5)
 Méthode d’affichage de la table client :
public static void afficher() {
try {
//3- Préparer, créer et exécuter une requête SQL
statement = connection.createStatement();
resultSetSelect = statement.executeQuery("select * from
`client`");
//4- Traiter le résultat
System.out.println("La liste des clients enregistrée
dans la base de données : ");
while(resultSetSelect.next()) {
String Nom = resultSetSelect.getString("nom");
String Prenom = resultSetSelect.getString("prenom");
System.out.println(Nom + " " + Prenom);
}
} catch (SQLException e) { e.printStackTrace(); }
}
28
Se connecter aux bases de données :
Exemple avec MySQL: (INSERT) (5/5)
 Méthode principal :
public static void main(String[] args) {
charger();
inserer();
afficher();
}

29
 Se connecter aux bases de données :
Exemple avec MySQL: (INSERT)
 2ème méthode :
1 2
public static void inserer(String nom, String prenom){
try {
sql = "insert into `client`(`nom`, `prenom`) values(?, ?);";
//3- Préparer, créer et exécuter une requête SQL
preparedStatement = connection.preparedStatement(sql);
preparedStatement.setString(1, nom);
preparedStatement.setString(2, prenom);

resultSetInsert = preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
}

30
Se connecter aux bases de données :
Exemple avec MySQL: (UPDATE) (1/3)
 Pour la méthode update, on a deux méthodes :
 1ère méthode :

public static void update(){

try {
sql = "update `client` set `nom`='khamlichi',
`prenom`='youness' where `id`=3;";
//3- Préparer, créer et exécuter une requête SQL
statement = connection.createStatement();
resultSetInsert = statement.executeUpdate(sql);
} catch (SQLException e) {
e.printStackTrace();
}
}

31
Se connecter aux bases de données :
Exemple avec MySQL: (UPDATE) (2/3)
 2ème méthode :
public static void update(int id, String nom, String prenom){
try {
sql = "update client set nom=?, prenom=? where id=?;";
//3- Préparer, créer et exécuter une requête SQL
PreparedStatement pStatement =
connection.prepareStatement(sql);
//ajouter les paramètres du preparedStatement
pStatement.setString(1, nom);
pStatement.setString(2, prenom);
pStatement.setInt(3, id);
resultSetInsert = pStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
}

32
Se connecter aux bases de données :
Exemple avec MySQL: (UPDATE) (3/3)
 Méthode main :
public static void main(String[] args) {
charger();
//inserer();
update(5, "khamlichi", "salah");
afficher();
fermetureBase();
}

public static void fermetureBase(){

try {
connection.close();
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
33
Se connecter aux bases de données :
Exemple avec MySQL: (DELETE)
 Méthode supprimer() :
public static void supprimer(int id) {
try {
sql = "delete from client where id=?";
//3- Préparer, créer et exécuter une requête SQL
preparedStatement = connection.prepareStatement(sql);
//ajouter les paramètres du preparedStatement
preparedStatement.setInt(1, id);
resultSetInsert = preparedStatement.executeUpdate();
System.out.println("Le Client N° : " + id + " a été
bien supprimé");
} catch (SQLException e) {
e.printStackTrace();
}
}

34
Fichier config.properties

########## Configuration accès SGBD ############

mysql.driver=com.mysql.jdbc.Driver
mysql.connexion=jdbc:mysql://localhost/
mysql.login=root
mysql.password=

35
Code source
public static void charger () {
ResourceBundle bundle =
ResourceBundle.getBundle("domaine.properties.config");
driver = bundle.getString("mysql.driver");
base = "agro";
connexion = bundle.getString("mysql.connexion") + base;
mysqlUser = bundle.getString("mysql.login");
mysqlPassword = bundle.getString("mysql.password");

try {
// Charger le pilote
Class.forName(driver); System.out.println("Driver loaded ...");

// Se connecter à la base de données

connection = DriverManager.getConnection(connexion, mysqlUser,
mysqlPassword);
} catch (ClassNotFoundException | SQLException e) {
System.err.println(e.getMessage()); } }
36